bool project::is_project_file(const std::string& fpath) {
return std::string{std::find_if(crbegin(fpath),
crend(fpath),
[](auto i) { return i == '.'; })
.base(),
end(fpath)} == project_extension;
}
Chain& scaled_add( const Coefficient & a, const Chain& rhs,
Persistence_data & data,
Chain & result, Compare c = Compare()){
typedef typename Chain::const_reverse_iterator Iterator_;
Iterator_ first = crbegin();
Iterator_ rhs_first = rhs.crbegin();
Iterator_ end = crend();
Iterator_ rhs_end = rhs.crend();
std::size_t n = size() + rhs.size();
//Z2 only:
//Walk up the chain from bottom to top looking for
//the first mismatch.
//If it exists the younger of the two is the next
//youngest element.
mismatch_prefetch( first, end, rhs_first, rhs_end, c,
data, n, coeff_tag());
if( result._chain.size() < n){ result._chain.resize( n); }
auto _end =
ctl::detail::chain_add( first, end, a, rhs_first, rhs_end,
result.rbegin(),
std::bind(c, std::placeholders::_2,
std::placeholders::_1),
coeff_tag());
result._chain.erase( _end, result.rend());
_chain.swap( result._chain);
return *this;
}
void for_each_demo(){
std::vector<int> v{5,4,3,2,1};
std::cout << std::accumulate(begin(v),end(v),0)<< " = sum\n";
for_each(begin(v),end(v),[](auto x){
std::cout << x++ << '\n';});
for_each(crbegin(v),crend(v),print);
copydemo(v);
}
void
exit_handler_intel_x64::unittest_1009_containers_set() const
{
auto myset = std::set<int>({0, 1, 2, 3});
auto myset2 = std::set<int>({0, 1, 2, 3});
auto total = 0;
for (auto iter = myset.begin(); iter != myset.end(); iter++)
total += *iter;
auto rtotal = 0;
for (auto iter = myset.rbegin(); iter != myset.rend(); iter++)
rtotal += *iter;
auto ctotal = 0;
for (auto iter = myset.cbegin(); iter != myset.cend(); iter++)
ctotal += *iter;
auto crtotal = 0;
for (auto iter = myset.crbegin(); iter != myset.crend(); iter++)
crtotal += *iter;
expect_true(total == 6);
expect_true(rtotal == 6);
expect_true(ctotal == 6);
expect_true(crtotal == 6);
expect_true(myset.size() == 4);
expect_true(myset.max_size() >= 4);
expect_false(myset.empty());
myset.insert(myset.begin(), 0);
myset.erase(myset.begin());
myset = myset2;
myset.swap(myset2);
myset.swap(myset2);
myset.emplace();
myset.emplace_hint(myset.begin());
myset = myset2;
myset.key_comp();
myset.value_comp();
expect_true(myset.find(0) != myset.end());
expect_true(myset.count(0) == 1);
expect_true(myset.lower_bound(0) != myset.end());
expect_true(myset.upper_bound(0) != myset.end());
myset.equal_range(0);
myset.get_allocator();
myset.clear();
}
void iterators() {
printf("iterators test begin\n");
auto list = XorLinkedList<Shouter>({Shouter(0),Shouter(1),Shouter(2)});
for (auto i = list.begin(); i != list.end(); ++i) {
//iterator is mutable
i->setI(i->i + 2);
}
for (auto i = list.cbegin(); i != list.cend(); ++i) {
//i->setI(i->i + 2); //error: iterator is const
i->hw(); //good, const methods
}
for (auto i = list.rbegin(); i != list.rend(); ++i) {
//reverse iterator is mutable
i->setI(i->i + 2);
}
for (auto i = list.crbegin(); i != list.crend(); ++i) {
//i->setI(i->i + 2); //error: iterator is const
i->hw(); //good, const methods
}
printf("iterators test end\n");
}
void pcnn_dynamic::allocate_sync_ensembles(ensemble_data<pcnn_ensemble> & ensembles) const {
std::unordered_set<unsigned int> traverse_oscillators;
traverse_oscillators.reserve(number_oscillators());
for (const_reverse_iterator iter_state = crbegin(); iter_state != crend(); iter_state++) {
pcnn_ensemble ensemble;
const pcnn_network_state & state_network = (*iter_state);
for (unsigned int i = 0; i < number_oscillators(); i++) {
if (state_network.m_output[i] == OUTPUT_ACTIVE_STATE) {
if (traverse_oscillators.find(i) == traverse_oscillators.end()) {
ensemble.push_back(i);
traverse_oscillators.insert(i);
}
}
}
if (!ensemble.empty()) {
ensembles.push_back(ensemble);
}
}
}
std::ostream& PreciseDecimal::toStream( std::ostream& os ) const
{
if( myInteger == 0 && myDecimal == 0 )
{
os << "0";
return os;
}
if( myIsNegative )
{
os << "-";
}
os << myInteger;
if( myDecimal == 0 )
{
return os;
}
os << ".";
auto decIntStr = std::to_string( myDecimal );
std::stringstream ss;
bool isNonZeroReached = false;
for ( auto c = decIntStr.crbegin();
c != decIntStr.crend();
++c )
{
if( *c == '0' && !isNonZeroReached )
{
continue;
}
isNonZeroReached = true;
ss << *c;
}
const auto backwards = ss.str();
short digits = 0;
decltype( myDecimal ) tens = 1;
for( int i = 0; i <= myMaxDecimalDigits; ++i )
{
++digits;
tens *= 10;
const auto r = myDecimal / tens;
if( r < 1 )
{
break;
}
}
short leadingZeros = myMaxDecimalDigits - digits;
for ( short i = 0; i < leadingZeros; ++i )
{
os << "0";
}
for ( auto c = backwards.crbegin();
c != backwards.crend();
++c )
{
os << *c;
}
return os;
}
cell_vector::const_reverse_iterator cell_vector::rend() const
{
return crend();
}
void
exit_handler_intel_x64::unittest_1002_containers_vector() const
{
auto myvector = std::vector<int>({0, 1, 2, 3});
auto myvector2 = std::vector<int>({0, 1, 2, 3});
auto total = 0;
for (auto iter = myvector.begin(); iter != myvector.end(); iter++)
total += *iter;
auto rtotal = 0;
for (auto iter = myvector.rbegin(); iter != myvector.rend(); iter++)
rtotal += *iter;
auto ctotal = 0;
for (auto iter = myvector.cbegin(); iter != myvector.cend(); iter++)
ctotal += *iter;
auto crtotal = 0;
for (auto iter = myvector.crbegin(); iter != myvector.crend(); iter++)
crtotal += *iter;
expect_true(total == 6);
expect_true(rtotal == 6);
expect_true(ctotal == 6);
expect_true(crtotal == 6);
expect_true(myvector.size() == 4);
expect_true(myvector.max_size() >= 4);
myvector.resize(4);
expect_true(myvector.capacity() >= 4);
expect_false(myvector.empty());
myvector.reserve(4);
myvector.shrink_to_fit();
expect_true(myvector.at(0) == 0);
expect_true(myvector.at(3) == 3);
expect_true(myvector.front() == 0);
expect_true(myvector.back() == 3);
expect_true(myvector.data() != nullptr);
myvector.assign(4, 0);
myvector = myvector2;
myvector.push_back(4);
myvector.pop_back();
myvector = myvector2;
myvector.insert(myvector.begin(), 0);
myvector.erase(myvector.begin());
myvector = myvector2;
myvector.swap(myvector2);
std::swap(myvector, myvector2);
myvector.emplace(myvector.begin());
myvector.emplace_back();
myvector = myvector2;
expect_true(myvector == myvector2);
expect_false(myvector != myvector2);
expect_false(myvector < myvector2);
expect_false(myvector > myvector2);
expect_true(myvector <= myvector2);
expect_true(myvector >= myvector2);
myvector = myvector2;
myvector.get_allocator();
myvector.clear();
}
void
exit_handler_intel_x64::unittest_100A_containers_map() const
{
auto mymap = std::map<int, int>();
auto mymap2 = std::map<int, int>();
mymap2[0] = 0;
mymap2[1] = 1;
mymap2[2] = 2;
mymap2[3] = 3;
mymap = mymap2;
auto total = 0;
for (auto iter = mymap.begin(); iter != mymap.end(); iter++)
total += iter->second;
auto rtotal = 0;
for (auto iter = mymap.rbegin(); iter != mymap.rend(); iter++)
rtotal += iter->second;
auto ctotal = 0;
for (auto iter = mymap.cbegin(); iter != mymap.cend(); iter++)
ctotal += iter->second;
auto crtotal = 0;
for (auto iter = mymap.crbegin(); iter != mymap.crend(); iter++)
crtotal += iter->second;
expect_true(total == 6);
expect_true(rtotal == 6);
expect_true(ctotal == 6);
expect_true(crtotal == 6);
expect_true(mymap.size() == 4);
expect_true(mymap.max_size() >= 4);
expect_false(mymap.empty());
expect_true(mymap.at(0) == 0);
expect_true(mymap.at(3) == 3);
mymap.insert(std::pair<int, int>(4, 4));
mymap.erase(4);
mymap = mymap2;
mymap.swap(mymap2);
mymap.swap(mymap2);
mymap.emplace();
mymap.emplace_hint(mymap.begin(), std::pair<int, int>(4, 4));
mymap = mymap2;
mymap.key_comp();
mymap.value_comp();
expect_true(mymap.find(0) != mymap.end());
expect_true(mymap.count(0) == 1);
expect_true(mymap.lower_bound(0) != mymap.end());
expect_true(mymap.upper_bound(0) != mymap.end());
mymap.equal_range(0);
mymap.get_allocator();
mymap.clear();
}
void system_contract::update_elected_producers(time cycle_time) {
producers_table producers_tbl( _self, _self );
auto idx = producers_tbl.template get_index<N(prototalvote)>();
std::array<uint32_t, 21> base_per_transaction_net_usage;
std::array<uint32_t, 21> base_per_transaction_cpu_usage;
std::array<uint32_t, 21> base_per_action_cpu_usage;
std::array<uint32_t, 21> base_setcode_cpu_usage;
std::array<uint32_t, 21> per_signature_cpu_usage;
std::array<uint32_t, 21> per_lock_net_usage;
std::array<uint64_t, 21> context_free_discount_cpu_usage_num;
std::array<uint64_t, 21> context_free_discount_cpu_usage_den;
std::array<uint32_t, 21> max_transaction_cpu_usage;
std::array<uint32_t, 21> max_transaction_net_usage;
std::array<uint64_t, 21> max_block_cpu_usage;
std::array<uint32_t, 21> target_block_cpu_usage_pct;
std::array<uint64_t, 21> max_block_net_usage;
std::array<uint32_t, 21> target_block_net_usage_pct;
std::array<uint32_t, 21> max_transaction_lifetime;
std::array<uint16_t, 21> max_authority_depth;
std::array<uint32_t, 21> max_transaction_exec_time;
std::array<uint16_t, 21> max_inline_depth;
std::array<uint32_t, 21> max_inline_action_size;
std::array<uint32_t, 21> max_generated_transaction_count;
std::array<uint32_t, 21> max_transaction_delay;
std::array<uint32_t, 21> percent_of_max_inflation_rate;
std::array<uint32_t, 21> storage_reserve_ratio;
eosio::producer_schedule schedule;
schedule.producers.reserve(21);
size_t n = 0;
for ( auto it = idx.crbegin(); it != idx.crend() && n < 21 && 0 < it->total_votes; ++it ) {
if ( it->active() ) {
schedule.producers.emplace_back();
schedule.producers.back().producer_name = it->owner;
//eosio_assert( sizeof(schedule.producers.back().block_signing_key) == it->packed_key.size(), "size mismatch" );
schedule.producers.back().block_signing_key = eosio::unpack<public_key>( it->packed_key );
//std::copy( it->packed_key.begin(), it->packed_key.end(), schedule.producers.back().block_signing_key.data.data() );
base_per_transaction_net_usage[n] = it->prefs.base_per_transaction_net_usage;
base_per_transaction_cpu_usage[n] = it->prefs.base_per_transaction_cpu_usage;
base_per_action_cpu_usage[n] = it->prefs.base_per_action_cpu_usage;
base_setcode_cpu_usage[n] = it->prefs.base_setcode_cpu_usage;
per_signature_cpu_usage[n] = it->prefs.per_signature_cpu_usage;
per_lock_net_usage[n] = it->prefs.per_lock_net_usage;
context_free_discount_cpu_usage_num[n] = it->prefs.context_free_discount_cpu_usage_num;
context_free_discount_cpu_usage_den[n] = it->prefs.context_free_discount_cpu_usage_den;
max_transaction_cpu_usage[n] = it->prefs.max_transaction_cpu_usage;
max_transaction_net_usage[n] = it->prefs.max_transaction_net_usage;
max_block_cpu_usage[n] = it->prefs.max_block_cpu_usage;
target_block_cpu_usage_pct[n] = it->prefs.target_block_cpu_usage_pct;
max_block_net_usage[n] = it->prefs.max_block_net_usage;
target_block_net_usage_pct[n] = it->prefs.target_block_net_usage_pct;
max_transaction_lifetime[n] = it->prefs.max_transaction_lifetime;
max_authority_depth[n] = it->prefs.max_authority_depth;
max_transaction_exec_time[n] = it->prefs.max_transaction_exec_time;
max_inline_depth[n] = it->prefs.max_inline_depth;
max_inline_action_size[n] = it->prefs.max_inline_action_size;
max_generated_transaction_count[n] = it->prefs.max_generated_transaction_count;
max_transaction_delay[n] = it->prefs.max_transaction_delay;
storage_reserve_ratio[n] = it->prefs.storage_reserve_ratio;
percent_of_max_inflation_rate[n] = it->prefs.percent_of_max_inflation_rate;
++n;
}
}
if ( n == 0 ) { //no active producers with votes > 0
return;
}
if ( 1 < n ) {
std::sort( base_per_transaction_net_usage.begin(), base_per_transaction_net_usage.begin()+n );
std::sort( base_per_transaction_cpu_usage.begin(), base_per_transaction_cpu_usage.begin()+n );
std::sort( base_per_action_cpu_usage.begin(), base_per_action_cpu_usage.begin()+n );
std::sort( base_setcode_cpu_usage.begin(), base_setcode_cpu_usage.begin()+n );
std::sort( per_signature_cpu_usage.begin(), per_signature_cpu_usage.begin()+n );
std::sort( per_lock_net_usage.begin(), per_lock_net_usage.begin()+n );
std::sort( context_free_discount_cpu_usage_num.begin(), context_free_discount_cpu_usage_num.begin()+n );
std::sort( context_free_discount_cpu_usage_den.begin(), context_free_discount_cpu_usage_den.begin()+n );
std::sort( max_transaction_cpu_usage.begin(), max_transaction_cpu_usage.begin()+n );
std::sort( max_transaction_net_usage.begin(), max_transaction_net_usage.begin()+n );
std::sort( max_block_cpu_usage.begin(), max_block_cpu_usage.begin()+n );
std::sort( target_block_cpu_usage_pct.begin(), target_block_cpu_usage_pct.begin()+n );
std::sort( max_block_net_usage.begin(), max_block_net_usage.begin()+n );
std::sort( target_block_net_usage_pct.begin(), target_block_net_usage_pct.begin()+n );
std::sort( max_transaction_lifetime.begin(), max_transaction_lifetime.begin()+n );
std::sort( max_transaction_exec_time.begin(), max_transaction_exec_time.begin()+n );
std::sort( max_authority_depth.begin(), max_authority_depth.begin()+n );
std::sort( max_inline_depth.begin(), max_inline_depth.begin()+n );
std::sort( max_inline_action_size.begin(), max_inline_action_size.begin()+n );
std::sort( max_generated_transaction_count.begin(), max_generated_transaction_count.begin()+n );
std::sort( max_transaction_delay.begin(), max_transaction_delay.begin()+n );
std::sort( storage_reserve_ratio.begin(), storage_reserve_ratio.begin()+n );
std::sort( percent_of_max_inflation_rate.begin(), percent_of_max_inflation_rate.begin()+n );
}
// should use producer_schedule_type from libraries/chain/include/eosio/chain/producer_schedule.hpp
bytes packed_schedule = pack(schedule);
set_active_producers( packed_schedule.data(), packed_schedule.size() );
size_t median = n/2;
global_state_singleton gs( _self, _self );
auto parameters = gs.exists() ? gs.get() : get_default_parameters();
parameters.base_per_transaction_net_usage = base_per_transaction_net_usage[median];
parameters.base_per_transaction_cpu_usage = base_per_transaction_cpu_usage[median];
parameters.base_per_action_cpu_usage = base_per_action_cpu_usage[median];
parameters.base_setcode_cpu_usage = base_setcode_cpu_usage[median];
parameters.per_signature_cpu_usage = per_signature_cpu_usage[median];
parameters.per_lock_net_usage = per_lock_net_usage[median];
parameters.context_free_discount_cpu_usage_num = context_free_discount_cpu_usage_num[median];
parameters.context_free_discount_cpu_usage_den = context_free_discount_cpu_usage_den[median];
parameters.max_transaction_cpu_usage = max_transaction_cpu_usage[median];
parameters.max_transaction_net_usage = max_transaction_net_usage[median];
parameters.max_block_cpu_usage = max_block_cpu_usage[median];
parameters.target_block_cpu_usage_pct = target_block_cpu_usage_pct[median];
parameters.max_block_net_usage = max_block_net_usage[median];
parameters.target_block_net_usage_pct = target_block_net_usage_pct[median];
parameters.max_transaction_lifetime = max_transaction_lifetime[median];
parameters.max_transaction_exec_time = max_transaction_exec_time[median];
parameters.max_authority_depth = max_authority_depth[median];
parameters.max_inline_depth = max_inline_depth[median];
parameters.max_inline_action_size = max_inline_action_size[median];
parameters.max_generated_transaction_count = max_generated_transaction_count[median];
parameters.max_transaction_delay = max_transaction_delay[median];
parameters.storage_reserve_ratio = storage_reserve_ratio[median];
parameters.percent_of_max_inflation_rate = percent_of_max_inflation_rate[median];
// not voted on
parameters.first_block_time_in_cycle = cycle_time;
// derived parameters
auto half_of_percentage = parameters.percent_of_max_inflation_rate / 2;
auto other_half_of_percentage = parameters.percent_of_max_inflation_rate - half_of_percentage;
parameters.payment_per_block = payment_per_block(half_of_percentage);
parameters.payment_to_eos_bucket = payment_per_block(other_half_of_percentage);
parameters.blocks_per_cycle = blocks_per_producer * schedule.producers.size();
if ( parameters.max_storage_size < parameters.total_storage_bytes_reserved ) {
parameters.max_storage_size = parameters.total_storage_bytes_reserved;
}
auto issue_quantity = parameters.blocks_per_cycle * (parameters.payment_per_block + parameters.payment_to_eos_bucket);
INLINE_ACTION_SENDER(eosio::token, issue)( N(eosio.token), {{N(eosio),N(active)}},
{N(eosio), issue_quantity, std::string("producer pay")} );
set_blockchain_parameters( parameters );
gs.set( parameters, _self );
}
