void Solution::nextPermutation(std::vector<int>& numbers) { auto it = numbers.rbegin(); for (; it != numbers.rend(); ++it) { auto head_it = it.base(); if (head_it == numbers.end()) { continue; } if (*it < *head_it) { break; } } if (it == numbers.rend()) { std::reverse(numbers.rbegin(), numbers.rend()); return; } const auto find_it = std::upper_bound(numbers.rbegin(), it, *it, std::less<>()); assert(find_it != numbers.rend()); std::iter_swap(it, find_it); std::reverse(numbers.rbegin(), it); }
/// \param[in] t_params the list of params to search /// \param[in] t_value the value to search for /// \returns the JobParam matching the given value. Throws an exception if it is not found static bool hasByValue(const std::vector<JobParam> &t_params, const std::string &t_value) { auto itr = std::find_if(t_params.rbegin(), t_params.rend(), JobParamValueCompare(t_value)); if (itr != t_params.rend()) { return true; } return false; }
std::vector<int> prevPerm(std::vector<int> data) { auto inversionPoint = std::is_sorted_until(data.rbegin(), data.rend(), [&data](const int& a, const int& b) { return a > b; }); if (inversionPoint == data.rend()) { return {}; } auto mostLowerBound = std::lower_bound(data.rbegin(), inversionPoint, *inversionPoint, cmp); std::iter_swap(mostLowerBound, inversionPoint); std::reverse(data.rbegin(), inversionPoint); return data; }
void HelloWorld::createActionChain(const std::vector<TileData*>& path) { if (path.size() <= 0) return; Size mapSize = m_gamemap->getMapSize(); Size tilesize = m_gamemap->getTileSize(); int mapheight = mapSize.height * tilesize.height; Vector<FiniteTimeAction*> actions; std::vector<TileData*>::const_reverse_iterator rIter = path.rbegin(); rIter++; while (rIter != path.rend()) { int destination_x = (*rIter)->position().first * tilesize.width + tilesize.width / 2; int destination_y = (*rIter)->position().second * tilesize.height + tilesize.height / 2; Vec2 destination(destination_x, mapheight - destination_y); MoveTo* action = MoveTo::create(0.5f, destination); actions.pushBack(action); rIter++; } if (actions.size() > 0) { Sequence* action_seq = Sequence::create(actions); m_player->runAction(action_seq); } }
void SpritesPanelImpl::traverseSprites(const std::vector<d2d::ISprite*>& sprites, IVisitor& visitor, TraverseType type/* = e_allExisting*/, bool order/* = true*/) { if (order) { std::vector<ISprite*>::const_iterator itr = sprites.begin(); for ( ; itr != sprites.end(); ++itr) { bool hasNext; visitor.visit(*itr, hasNext); if (!hasNext) break; } } else { std::vector<ISprite*>::const_reverse_iterator itr = sprites.rbegin(); for ( ; itr != sprites.rend(); ++itr) { bool hasNext; visitor.visit(*itr, hasNext); if (!hasNext) break; } } }
bool updateLeavesSpawn() { bool fullGridSpawn = (newLeaves.size() == (unsigned)theHeriswapGridSystem.GridSize*theHeriswapGridSystem.GridSize); ADSR(haveToAddLeavesInGrid)->active = true; for ( std::vector<Feuille>::reverse_iterator it = newLeaves.rbegin(); it != newLeaves.rend(); ++it ) { if (it->entity == 0) { it->entity = createCell(*it, fullGridSpawn); } else { HeriswapGridComponent* gc = HERISWAPGRID(it->entity); if (fullGridSpawn) { gc->i = gc->j = -1; } TransformationComponent* tc = TRANSFORM(it->entity); //leaves grow up from 0 to fixed size glm::vec2 s = HeriswapGame::CellSize(theHeriswapGridSystem.GridSize, gc->type); if (ADSR(haveToAddLeavesInGrid)->value == 1){ tc->size = glm::vec2(s.x, s.y); gc->i = it->X; gc->j = it->Y; } else { tc->size = s * ADSR(haveToAddLeavesInGrid)->value; } } } return (ADSR(haveToAddLeavesInGrid)->value == 1); }
void CountingSort::rcsort(std::vector<unsigned int>& A, std::vector<unsigned int>& B, unsigned int d) { std::vector<unsigned int> C(10); for (auto c = C.begin(); c != C.end(); ++c) *c = 0; //std::cout << "C: "; print(C); for (auto a = A.begin(); a != A.end(); ++a) ++C[digit(*a,d)]; //std::cout << "A: "; print(A); //std::cout << "C: "; print(C); for (auto c = C.begin() + 1; c != C.end(); ++c) *c += *(c - 1); //std::cout << "C: "; print(C); for (auto a = A.rbegin(); a != A.rend(); ++a) { B[C[digit(*a,d)] - 1] = *a; --C[digit(*a,d)]; } }
int testFindDistanceBetween(const std::string & s1, const std::string & s2, const std::vector<std::string> & fileAsAnArray) { if (s1.compare(s2) == 0) { return 0; } int minDistance = INT_MAX; bool found = false; for (auto it = fileAsAnArray.begin(); it != fileAsAnArray.end(); ++it) { if (it->compare(s1) == 0) { found = true; auto itBack = std::vector<std::string>::const_reverse_iterator(it); --itBack; // When converted, it points to predecessor of it auto beginR = itBack; assert(beginR->compare(*it) == 0); auto itForth = it; auto distance = INT_MAX; while (itBack != fileAsAnArray.rend()) { if (itBack->compare(s2) == 0) { distance = abs(std::distance(itBack, beginR)); break; } ++itBack; } while (itForth != fileAsAnArray.end()) { if (itForth->compare(s2) == 0) { distance = min(distance, abs(std::distance(it, itForth))); break; } ++itForth; } minDistance = min(distance, minDistance); } } if (!found) { return -1; } return minDistance; }
template <typename PointT> void pcl16::EuclideanClusterExtraction<PointT>::extract (std::vector<PointIndices> &clusters) { if (!initCompute () || (input_ != 0 && input_->points.empty ()) || (indices_ != 0 && indices_->empty ())) { clusters.clear (); return; } // Initialize the spatial locator if (!tree_) { if (input_->isOrganized ()) tree_.reset (new pcl16::search::OrganizedNeighbor<PointT> ()); else tree_.reset (new pcl16::search::KdTree<PointT> (false)); } // Send the input dataset to the spatial locator tree_->setInputCloud (input_, indices_); extractEuclideanClusters (*input_, *indices_, tree_, static_cast<float> (cluster_tolerance_), clusters, min_pts_per_cluster_, max_pts_per_cluster_); //tree_->setInputCloud (input_); //extractEuclideanClusters (*input_, tree_, cluster_tolerance_, clusters, min_pts_per_cluster_, max_pts_per_cluster_); // Sort the clusters based on their size (largest one first) std::sort (clusters.rbegin (), clusters.rend (), comparePointClusters); deinitCompute (); }
extern "C" NS_EXPORT pid_t WRAP(fork)(void) { pid_t pid; for (std::vector<AtForkFuncs>::reverse_iterator it = atfork.rbegin(); it < atfork.rend(); ++it) if (it->prepare) it->prepare(); switch ((pid = __fork())) { case 0: cpuacct_add(getuid()); for (std::vector<AtForkFuncs>::iterator it = atfork.begin(); it < atfork.end(); ++it) if (it->child) it->child(); break; default: for (std::vector<AtForkFuncs>::iterator it = atfork.begin(); it < atfork.end(); ++it) if (it->parent) it->parent(); } return pid; }
/* ** Trims empty element in vector and white-space in each string. ** */ void CConfigParser::Shrink(std::vector<std::wstring>& vec) { if (!vec.empty()) { std::vector<std::wstring>::reverse_iterator iter = vec.rbegin(); while (iter != vec.rend()) { std::wstring::size_type pos = (*iter).find_first_not_of(L" \t\r\n"); if (pos != std::wstring::npos) { std::wstring::size_type lastPos = (*iter).find_last_not_of(L" \t\r\n"); if (pos != 0 || lastPos != ((*iter).size() - 1)) { // Trim white-space (*iter).assign((*iter), pos, lastPos - pos + 1); } ++iter; } else { // Remove empty element vec.erase((++iter).base()); } } } }
void CSVExporter::processData(const unsigned char* buffer, size_t bufferSize, float baseTime, const std::vector<ProcedureDescription>& proceduresDescriptions) { file << "name;pid;num_threads;item_input;input_size;shared_memory" << std::endl; for (auto p = proceduresDescriptions.rbegin(); p != proceduresDescriptions.rend(); ++p) { file << p->name << ';' << p->ProcedureId << ';' << p->NumThreads << ';' << p->ItemInput << ';' << p->inputSize << ';' << p->sharedMemory << '\n'; } file << std::endl; file << "t0;t1;pid;mpid;active_threads;overhead_counter;dequeue_time;{enqueue_stats_pid;enqueue_stats_count}" << std::endl; for (const unsigned char* data = buffer; data < buffer + bufferSize;) { int num_enqueue_stats = Instrumentation::unpack_num_enqueue_stats(data); file << Instrumentation::unpack_t0(data) << ';' << Instrumentation::unpack_t1(data) << ';' << Instrumentation::unpack_pid(data) << ';' << Instrumentation::unpack_mpid(data) << ';' << Instrumentation::unpack_active_threads(data) << ';' << Instrumentation::unpack_overhead_counter(data) << ';' << Instrumentation::unpack_dequeue_time(data); if (num_enqueue_stats > 0) { for (int i = 0; i < num_enqueue_stats; ++i) file << ';'<< Instrumentation::unpack_enqueue_stat_pid(data, i) << ';'<< Instrumentation::unpack_enqueue_stat_count(data, i); } file << std::endl; data = Instrumentation::next_element(data, num_enqueue_stats); } file << std::endl; }
bool ParserMixin::convertStringElementsToPackageElements(const ParseContextSPtr& context, const std::vector<std::string>& string_elements, std::vector<PackageElementSPtr>& package_elements) { std::vector<PackageElementSPtr>::const_reverse_iterator eit = context->mSourceId->externalElements().rbegin(); std::vector<std::string>::const_reverse_iterator it; for (it = string_elements.rbegin(); it != string_elements.rend(); ++it) { PackageElementSPtr pe; if (*it == "*") { if (eit == context->mSourceId->externalElements().rend()) { context->mMessageCollector->addMessage(errorMessage(context, Message::p_asteriskPackageElement)); return false; } pe = *eit; ++eit; } else { if (*eit && (*eit)->value() == *it) ++eit; pe = boost::make_shared<PackageElement>(); pe->set_value(*it); } package_elements.insert(package_elements.begin(), pe); } return true; }
size_t CountDistinctValues(std::vector<int> numbers){ size_t abs_count = numbers.size(); auto f_it = numbers.begin(); auto r_it = numbers.rbegin(); while(f_it != numbers.end() && r_it != numbers.rend()){ //std::cout << "Forward iterator: " << *f_it << std::endl; //std::cout << "Reverse iterator: " << *r_it << std::endl; if((f_it - numbers.begin()) + (r_it - numbers.rbegin()) == numbers.size()-1) break; if(*f_it == *(f_it+1)){ // considering duplicates on the left side of an array --abs_count; ++f_it; continue; } if(*r_it == *(r_it+1)){ // considering duplicates on the right side of an array --abs_count; ++r_it; continue; } if(abs(*f_it) == abs(*r_it)){ --abs_count; ++f_it; ++r_it; } else if(abs(*f_it) > abs(*r_it)) ++f_it; else ++r_it; } return abs_count; }
void sdl_event_handler::mouse(const ui_event event, const point& position) { DBG_GUI_E << "Firing: " << event << ".\n"; if(mouse_focus) { mouse_focus->fire( event, dynamic_cast<widget&>(*mouse_focus), position); } else { for(std::vector<dispatcher*>::reverse_iterator ritor = dispatchers_.rbegin(); ritor != dispatchers_.rend(); ++ritor) { if((**ritor).get_mouse_behavior() == dispatcher::all) { (**ritor) .fire(event, dynamic_cast<widget&>(**ritor), position); break; } if((**ritor).get_mouse_behavior() == dispatcher::none) { continue; } if((**ritor).is_at(position)) { (**ritor) .fire(event, dynamic_cast<widget&>(**ritor), position); break; } } } }
LinguisticGraphVertex SyntacticAnalyzerNoChains::unstackUptoChainEnd( const SyntacticData* data, std::vector< ChainStackTuple >& pile, Common::MediaticData::ChainsType type ) const { /* Critical function : commeng logging messages */ // SACLOGINIT; // LDEBUG << "unstackUptoChainEnd " << (type==NOMINAL?"nominal":(type==VERBAL?"verbal":"none")); CVertexDataPropertyMap dataMap = get( vertex_data, (*data->iterator()->getGraph()) ); std::vector< ChainStackTuple >::const_reverse_iterator rit, rit_end; rit = pile.rbegin(); rit_end = pile.rend(); for (; rit != rit_end; rit++) { if ( data->matrices()->canChainEndBy(dataMap[(*rit).get<0>()], type)) break; // LDEBUG << "chain cannot finish by " << (*rit).get<0>(); } if (rit != rit_end) { LinguisticGraphVertex newChainEnd = (*rit).get<0>(); // LDEBUG << "Chain end found in pile: " << newChainEnd; return (newChainEnd); } else { // LDEBUG << "No chain end found in pile !"; return data->iterator()->firstVertex(); } }
static bool cw_sorted(const point_i ¢er, const std::vector<point_i> &points) { if (points.empty()) return true; const point_i start = points.front() - center; const point_i rev_start = points.back() - center; auto cw_less = [=](const point_i &lhs, const point_i &rhs) { return djp::cw_less(center, start, lhs, rhs); }; auto ccw_less = [=](const point_i &lhs, const point_i &rhs) { return djp::ccw_less(center, rev_start, lhs, rhs); }; const bool result = std::is_sorted(points.begin(), points.end(), cw_less); // Points in same angle should be considered equal i.e no one is less than // other. const bool rev_result = std::is_sorted(points.rbegin(), points.rend(), ccw_less); EXPECT_EQ(result, rev_result); return result; }
void GeometryShaderApp::mouseDown( MouseEvent event ) { // check if any of the points is clicked (distance < radius) std::vector<Vec2f>::reverse_iterator itr; for(itr=mPoints.rbegin();itr!=mPoints.rend();++itr) { float d = Vec2f( event.getPos() ).distance( *itr ); if(d < mRadius) { // start dragging mDragPos = event.getPos(); mDragFrom = *itr; mDragVecPtr = &(*itr); bIsDragging = true; // return; } } // not dragging, create new point mPoints.push_back( Vec2f( event.getPos() ) ); // ...and drag it right away mDragPos = event.getPos(); mDragFrom = mPoints.back(); mDragVecPtr = &(mPoints.back()); bIsDragging = true; // invalidate mesh mVboMesh = gl::VboMesh(); }
void TcpClientApp::update() { mFrameRate = getFrameRate(); // Toggle full screen. if ( mFullScreen != isFullScreen() ) { setFullScreen( mFullScreen ); mFullScreen = isFullScreen(); } // Render text. if ( !mText.empty() ) { TextBox tbox = TextBox().alignment( TextBox::LEFT ).font( mFont ).size( Vec2i( getWindowWidth() - 250, TextBox::GROW ) ).text( "" ); for ( vector<string>::const_reverse_iterator iter = mText.rbegin(); iter != mText.rend(); ++iter ) { tbox.appendText( "> " + *iter + "\n" ); } tbox.setColor( ColorAf( 1.0f, 0.8f, 0.75f, 1.0f ) ); tbox.setBackgroundColor( ColorAf::black() ); tbox.setPremultiplied( false ); mTexture = gl::Texture::create( tbox.render() ); while ( mText.size() > 75 ) { mText.erase( mText.begin() ); } } }
double TechUtils::CalulateWMA(const std::vector<TickWrapper>& data, const TickWrapper& current, size_t seconds) { //datetime to timestamp size_t n = seconds * 2; double totalExchangeLastPrice = current.LastPrice() * n; long long count = n--; long long leftedge = current.toTimeStamp() - seconds * 2; for (auto it = data.rbegin(); it != data.rend(); it++) { if (it->toTimeStamp() > leftedge){ totalExchangeLastPrice += (it->LastPrice() * n); --n; count += n; } else{ break; } } //assert(totalVolume != 0); //assert(totalExchangePrice >= 0.0); return totalExchangeLastPrice / count; }
void AttrCounter::getTopNameIds_( int topNum, std::vector<AttrTable::nid_t>& topNameIds) { if (topNum == 0) { topNum = nameValueCountTable_.size(); } AttrScoreQueue queue(topNum); for (NameValueCountTable::const_iterator it = nameValueCountTable_.begin(); it != nameValueCountTable_.end(); ++it) { AttrTable::nid_t nameId = it->first; int valueCount = it->second; double score = getNameScore_(nameId); if (score > 0 && valueCount >= minValueCount_) { AttrScore attrScore(nameId, score); queue.insert(attrScore); } } topNameIds.resize(queue.size()); for (std::vector<sf1r::faceted::AttrTable::nid_t>::reverse_iterator rit = topNameIds.rbegin(); rit != topNameIds.rend(); ++rit) { *rit = queue.pop().first; } }
void switchRegisterSelection(std::vector<std::string> RegisterToSelect) { registerToBeFound = NULL; QList<QTreeWidgetItem*> registerList = qtHardMon->ui.registerTreeWidget->findItems( RegisterToSelect.back().c_str(), Qt::MatchExactly | Qt::MatchRecursive); RegisterToSelect.pop_back(); for(std::vector<std::string>::reverse_iterator nameIter = RegisterToSelect.rbegin(); nameIter != RegisterToSelect.rend(); ++nameIter) { // Iterate the list until we find the one with the right module for(QList<QTreeWidgetItem*>::iterator registerIter = registerList.begin(); registerIter != registerList.end(); ++registerIter) { // if we found the right register select it and quit the loop if((*registerIter)->parent()->text(0) == (*nameIter).c_str()) { registerToBeFound = *registerIter; break; } } } if(!registerToBeFound) { BOOST_FAIL("Register not found..."); } else { qtHardMon->ui.registerTreeWidget->setCurrentItem(registerToBeFound); } }
void AlnusPhyolgeticBranch::setRowIndex(unsigned int baseIndex) { if (mChildren.empty()) { mRowIndex = baseIndex; return; } // unsigned int numberOfNodesInTheMostLeftChild = mChildren.front()->getNumberOfNodes() + 1; // Cumulative numbers of nodes in the reverse order std::vector<unsigned int> numbersOfNodesInRightChildren; unsigned int numberOfNodes = 0; numbersOfNodesInRightChildren.push_back(numberOfNodes); for (std::vector<AlnusPhyolgeticBranch*>::reverse_iterator i = mChildren.rbegin(); i != mChildren.rend(); i++) { numberOfNodes += (*i)->getNumberOfNodes() + 1; numbersOfNodesInRightChildren.push_back(numberOfNodes); } // Recursive calls mRowIndex = baseIndex - numbersOfNodesInRightChildren.at(mChildren.size() - 1); // assert(mRowIndex == numberOfNodesInTheMostLeftChild + 1); AlnusPhyolgeticBranch *branch = mChildren.at(0); branch->setRowIndex(mRowIndex - 1); for (size_t i = 1; i < mChildren.size(); i++) { branch = mChildren.at(i); unsigned int childBaseIndex = baseIndex - numbersOfNodesInRightChildren.at(mChildren.size() - 1 - i); branch->setRowIndex(childBaseIndex); } }
static mode_t get_device_perm(const char *path, const std::vector<std::string> &links, unsigned *uid, unsigned *gid) { // Search the perms list in reverse so that ueventd.$hardware can // override ueventd.rc for (auto it = dev_perms.rbegin(); it != dev_perms.rend(); ++it) { bool match = false; const struct perms_ &dp = *it; if (perm_path_matches(path, &dp)) { match = true; } else { for (const std::string &link : links) { if (perm_path_matches(link.c_str(), &dp)) { match = true; break; } } } if (match) { *uid = dp.uid; *gid = dp.gid; return dp.perm; } } // Default if nothing found. *uid = 0; *gid = 0; return 0600; }
void GxsChannelPostsWidget::insertChannelPosts(std::vector<RsGxsChannelPost> &posts, GxsMessageFramePostThread *thread, bool related) { if (related && thread) { std::cerr << "GxsChannelPostsWidget::insertChannelPosts fill only related posts as thread is not possible" << std::endl; return; } std::vector<RsGxsChannelPost>::const_reverse_iterator it; int count = posts.size(); int pos = 0; if (!thread) { ui->feedWidget->setSortingEnabled(false); } for (it = posts.rbegin(); it != posts.rend(); ++it) { if (thread && thread->stopped()) { break; } if (thread) { thread->emitAddPost(qVariantFromValue(*it), related, ++pos, count); } else { createPostItem(*it, related); } } if (!thread) { ui->feedWidget->setSortingEnabled(true); } }
int32_t rdConfLoader::handle_as_section(const char* line, std::vector<std::string>& paths) { paths.clear(); std::string line_trimed = rdStringUtil::trim(line); int32_t size = (int32_t)line_trimed.size(); if (size < 2 || '[' != line_trimed[0] || ']' != line_trimed[size - 1]) { return E_CONF_ERROR; } line_trimed = line_trimed.substr(1, size - 2); size -= 2; std::vector<std::string> v; rdStringUtil::split_string(line_trimed, ".", v, /*filter_empty = */false); if (0 == v.size()) { return E_CONF_ERROR; } std::vector<std::string>::iterator itr; for (itr = v.begin(); itr != v.end(); ++itr) { std::string s = rdStringUtil::trim(*itr); if (s.empty()) { return E_CONF_ERROR; } else { paths.push_back(s); } } std::vector<std::string>::reverse_iterator ritr; ritr = paths.rbegin(); if (ritr != paths.rend()) { ++ritr; while (ritr != paths.rend()) { if ('@' == (*ritr)[0]) { paths.clear(); return E_CONF_ERROR; } ++ritr; } } return 0; }
void FtpClientApp::update() { mFrameRate = getFrameRate(); if ( mFullScreen != isFullScreen() ) { setFullScreen( mFullScreen ); mFullScreen = isFullScreen(); } if ( !mText.empty() ) { TextBox tbox = TextBox() .alignment( TextBox::LEFT ) .font( mFont ) .size( ivec2( getWindowWidth() - 250, TextBox::GROW ) ) .text( "" ); for ( vector<string>::const_reverse_iterator iter = mText.rbegin(); iter != mText.rend(); ++iter ) { tbox.appendText( "> " + *iter + "\n" ); } tbox.setColor( ColorAf( 1.0f, 0.8f, 0.75f, 1.0f ) ); tbox.setBackgroundColor( ColorAf::black() ); tbox.setPremultiplied( false ); mTexture = gl::Texture::create( tbox.render() ); while ( mText.size() > 75 ) { mText.erase( mText.begin() ); } } if ( mConnectionControl->isConnected() && mConnectionControl->getBuffer() && mConnectionControl->getBuffer()->getSize() > 0 ) { const BufferRef& buffer = mConnectionControl->getBuffer(); string s = ProtocolInterface::bufferToString( buffer ); mFtpResponse.parse( buffer ); mText.push_back( mFtpResponse.toString() ); switch ( mFtpResponse.getReplyCode() ) { case FtpReplyCode_220_SERVICE_READY_FOR_NEW_USER: mFtpRequest.set( FtpCommand_USER, "****" ); mText.push_back( mFtpRequest.toString() ); // TODO get toBuffer to work here mConnectionControl->write( mFtpRequest.toBuffer() ); break; case FtpReplyCode_230_USER_LOGGED_IN_PROCEED: // TODO open data connection here break; case FtpReplyCode_331_USER_NAME_OKAY_NEED_PASSWORD: mFtpRequest.set( FtpCommand_PASS, "****" ); // TODO get toBuffer to work here mText.push_back( mFtpRequest.toString() ); mConnectionControl->write( mFtpRequest.toBuffer() ); break; default: mConnectionControl->close(); break; } } }
~CreatedGraphProperties() { /* First clear all consumers */ std::vector<std::shared_ptr<flitr::ImageConsumer>>::reverse_iterator consumerIter = consumers.rbegin(); while(consumerIter != consumers.rend()) { (*consumerIter) = nullptr; ++consumerIter; } consumers.clear(); /* Now only clear all the producers */ std::vector<std::shared_ptr<flitr::ImageProducer>>::reverse_iterator producerIter = producers.rbegin(); while(producerIter != producers.rend()) { (*producerIter) = nullptr; ++producerIter; } producers.clear(); }
/** * Sets the front of the Shoe to the given Card ranks and suits */ void FrontloadShoe(std::unique_ptr<Sim>& sim, std::vector<std::pair<int, int> > ranks) { auto& shoeCards = sim->GetGame()->GetShoe()->GetCards(); for (auto it = ranks.rbegin(); it != ranks.rend(); it++) { shoeCards.push_front(std::unique_ptr<Card>(new Card(it->first, it->second))); } return; }
void eddic::as::restore(AssemblyFileWriter& writer, const std::vector<std::string>& registers){ auto it = registers.rbegin(); auto end = registers.rend(); while(it != end){ writer.stream() << "pop " << *it << '\n'; ++it; } }