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::rbegin() const { return crbegin(); }
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(); }
const_reference back() const { assert(size() > 0); return *crbegin(); }
const_reverse_iterator crend() const noexcept{ return crbegin() + size(); }
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 ); }