void ModalListPicker::ModalInit() { m_dropped = true; // Try to center the current item unless within half the number of // shown rows from the top or bottom if (CurrentItem() != m_lb_wnd->end() && !m_lb_wnd->Empty()) { std::size_t current_ii(std::distance(m_lb_wnd->begin(), CurrentItem())); std::size_t half_shown((m_num_shown_rows / 2)); std::size_t even_extra_one((m_num_shown_rows % 2 == 0) ? 1 : 0); m_lb_wnd->SetFirstRowShown(m_lb_wnd->begin()); if (current_ii >= (m_lb_wnd->NumRows() - 1 - half_shown)) { m_lb_wnd->BringRowIntoView(--m_lb_wnd->end()); } else if (current_ii >= half_shown) { m_lb_wnd->SetFirstRowShown( std::next(m_lb_wnd->begin(), current_ii - half_shown + even_extra_one)); } } m_lb_wnd->Hide(); // to enable CorrectListSize() to work CorrectListSize(); Show(); }
virtual void _Reply_data(std::shared_ptr<protocol::Invoke> invoke) override final { if (invoke->has("_History_uid") == true) { // REGISTER THIS PROCESS ON HISTORY LIST std::shared_ptr<slave::InvokeHistory> history(new slave::InvokeHistory(invoke)); progress_list_.insert({ history->getUID(), history }); if (invoke->has("_Piece_first") == true) { // PARALLEL PROCESS size_t first = invoke->get("_Piece_first")->getValue<size_t>(); size_t last = invoke->get("_Piece_last")->getValue<size_t>(); invoke->erase(invoke->end() - 2, invoke->end()); ((base::ParallelSystemArrayBase*)system_array_)->sendPieceData(invoke, first, last); } else if (invoke->has("_Process_name") == true) { // DISTRIBUTED PROCESS auto ds_system_array = (distributed::base::DistributedSystemArrayBase*)system_array_; // FIND THE MATCHED ROLE const std::string &process_name = invoke->get("_Process_name")->getValue<std::string>(); if (ds_system_array->hasProcess(process_name) == false) return; // SEND DATA VIA THE ROLE auto process = ds_system_array->getProcess(process_name); ((distributed::base::DistributedProcessBase*)(process.get()))->sendData(invoke, 1.0); } } else replyData(invoke); };
void receive_hello(std::shared_ptr<tcp::socket> socket , std::shared_ptr<std::vector<std::uint8_t>> buffer , std::size_t const read_size = sizeof(ofp_header)) { auto const read_head = buffer->size(); buffer->resize(read_head + read_size); boost::asio::async_read(*socket , boost::asio::buffer(&(*buffer)[read_head], read_size) , boost::asio::transfer_exactly(read_size) , [=](boost::system::error_code const& ec, std::size_t const) { if (ec) { std::cout << "read error: " << ec.message() << std::endl; return; } auto const header = detail::read_ofp_header(boost::asio::buffer(*buffer)); if (header.type != hello::message_type) { std::cout << "not hello message" << std::endl; return; } if (header.length != buffer->size()) { receive_hello(std::move(socket), std::move(buffer), header.length - buffer->size()); return; } auto channel = std::make_shared<v10::secure_channel_impl<ControllerHandler>>( std::move(*socket), controller_handler_, *thread_pool_); auto it = buffer->begin(); channel->run(hello::decode(it, buffer->end())); }); }
static BufferInfoIterator findBufferId( const std::shared_ptr<const std::vector<const BufferInfo>> &array, IOMX::buffer_id bufferId) { return std::find_if( array->begin(), array->end(), [bufferId](const BufferInfo &info) { return bufferId == info.mBufferId; }); }
static BufferInfoIterator findClientBuffer( const std::shared_ptr<const std::vector<const BufferInfo>> &array, const sp<MediaCodecBuffer> &buffer) { return std::find_if( array->begin(), array->end(), [buffer](const BufferInfo &info) { return info.mClientBuffer == buffer; }); }
void Output::printBinary(std::shared_ptr<std::vector<char>> data) { try { if(!data || data->empty()) return; std::ostringstream stringstream; stringstream << std::hex << std::setfill('0') << std::uppercase; for(std::vector<char>::iterator i = data->begin(); i != data->end(); ++i) { stringstream << std::setw(2) << (int32_t)((uint8_t)(*i)); } stringstream << std::dec; std::cout << stringstream.str() << std::endl; } catch(const std::exception& ex) { printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what()); } catch(const Exception& ex) { printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what()); } catch(...) { printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__); } }
void IdRef::VisitCheck(std::shared_ptr<std::map<std::string, ast::Matrix>> vars, std::shared_ptr<reporter::ErrorReporter> reporter) const { auto varname = id->Spelling(); if (vars->find(varname) == vars->end()) throw "Undefined function or variable \'" + varname + "\'."; }
/** * This constructor populates this CountDB from file, reading the set of counts from fname. */ CountDB( const std::string& fname, std::shared_ptr<std::vector<Kmer>>& kmers, uint32_t merSize ) : _kmers(kmers), _merSize( merSize ) { std::cerr << "checking that kmers are sorted . . . "; assert( std::is_sorted( kmers->begin(), kmers->end() ) ); std::cerr << "done\n"; std::ifstream counts(fname, std::ios::in | std::ios::binary ); uint32_t fileMerSize{0}; counts.read( reinterpret_cast<char*>(&fileMerSize), sizeof(fileMerSize) ); std::cerr << "checking that the mersizes are the same . . ."; assert( fileMerSize == merSize ); std::cerr << "done\n"; size_t numCounts{0}; counts.read( reinterpret_cast<char*>(&numCounts), sizeof(size_t) ); std::cerr << "checking that the counts are the same . . ."; assert( numCounts == kmers->size() ); std::cerr << "done\n"; _counts = std::vector< AtomicCount >( numCounts ); std::cerr << "reading counts from file . . ."; counts.read( reinterpret_cast<char*>(&_counts[0]), sizeof(_counts[0]) * numCounts ); std::cerr << "done\n"; counts.close(); }
void PeerComm::HandleMessagePayload(std::shared_ptr<std::vector<char>> payload_, const boost::system::error_code& error) { if (!error) { QueueReceiveMessage(); auto id = (*payload_)[0]; std::vector<char> payload; payload.reserve(payload_->size() - 1); payload.insert(payload.end(), payload_->begin() + 1, payload_->end()); std::unique_lock<std::mutex> _(m_Mutex); switch ((Peer::MessageType)id) { case Peer::MessageType::Choke: m_State = PeerCommState::Choked; m_Incoming.push_back(std::make_unique<Peer::Choke>()); break; case Peer::MessageType::Unchoke: m_State = PeerCommState::Working; m_Incoming.push_back(std::make_unique<Peer::Unchoke>()); break; case Peer::MessageType::Interested: m_Incoming.push_back(std::make_unique<Peer::Interested>()); break; case Peer::MessageType::NotInterested: m_Incoming.push_back(std::make_unique<Peer::NotInterested>()); break; case Peer::MessageType::Have: m_Incoming.push_back(std::make_unique<Peer::Have>(payload)); break; case Peer::MessageType::Bitfield: m_Incoming.push_back(std::make_unique<Peer::Bitfield>(payload)); break; case Peer::MessageType::Request: m_Incoming.push_back(std::make_unique<Peer::Request>(payload)); break; case Peer::MessageType::Piece: m_Incoming.push_back(std::make_unique<Peer::Piece>(payload)); break; case Peer::MessageType::Cancel: m_Incoming.push_back(std::make_unique<Peer::Cancel>(payload)); break; case Peer::MessageType::Port: m_Incoming.push_back(std::make_unique<Peer::Port>(payload)); break; default: std::cout << "invalid message id" << std::endl; m_State = PeerCommState::Error; return; } } else { std::unique_lock<std::mutex> _(m_Mutex); m_State = PeerCommState::Error; } }
inline void operator() (args_t&&... args) const { //add ref bool erased = false; auto slot_list = m_slot_list; auto keysref = m_keys; auto keys = *keysref; for (size_t i = 0; i < keys.size(); ++i) { auto it = m_slot_list->find(keys[i]); if (it != m_slot_list->end()) { it->second(std::forward<args_t>(args)...); } else { erased = true; (*keysref)[i] = 0; } } if (erased) { keysref->erase(std::remove(keysref->begin(), keysref->end(), 0), keysref->end()); } }
rtf_reader(const std::shared_ptr<cainteoir::buffer> &aData) : cainteoir::buffer(aData->begin(), aData->end()) , mCurrent(aData->begin()) , mData(std::make_shared<cainteoir::buffer>(nullptr, nullptr)) , mParameter(0) , mDepth(0) { }
Slice<ItemType> ( std::list<std::shared_ptr<Slice<ItemType>>> others) : store(std::make_shared<Storage>()) { uintptr_t total_size = 0; for (auto it = others.begin(); it != others.end(); ++it) { total_size += (*it)->size(); }; store->reserve(total_size); for (auto it = others.begin(); it != others.end(); ++it) { store->insert(store->end(), (*it)->istart, (*it)->iend); }; istart = store->begin(); iend = store->end(); }
// Returns the value, for the given key, in that bucket, or 0 if not present. int64_t getBucketValue(const std::shared_ptr<DimToValMap>& bucket, const MetricDimensionKey& key) { const auto& itr = bucket->find(key); if (itr != bucket->end()) { return itr->second; } return 0; }
bool Session::prepare_for_run( std::shared_ptr< const adcontrols::ControlMethod::Method > m ) { if ( m ) { auto it = m->find( m->begin(), m->end(), acqrscontrols::ap240::method::clsid() ); // "ap240" ); if ( it != m->end() ) { auto method = std::make_shared< acqrscontrols::ap240::method >(); if ( it->get<>( *it, *method ) ) { task::instance()->prepare_for_run( method ); return true; } } } return false; }
void GroupTree::getNodes(std::shared_ptr< GroupTreeNode > fromNode, std::vector<std::shared_ptr< const GroupTreeNode >>& nodes) const { std::map<std::string, std::shared_ptr< GroupTreeNode > >::const_iterator iter = fromNode->begin(); while (iter != fromNode->end()) { std::shared_ptr< GroupTreeNode > child = (*iter).second; nodes.push_back(child); getNodes(child, nodes); ++iter; } }
size_t BitmapPrimitiveShape::AllConnectedComponents(const PointCloud &pc, float epsilon, BitmapInfo& bitmapInfo, std::shared_ptr<MiscLib::Vector< size_t > >indices, MiscLib::Vector< int >& componentsImg, MiscLib::Vector< std::pair< int, size_t > >& labels, bool doFiltering ) { // first find the extent in the parametrization // but remember the parametrized points for projection into a bitmap size_t size = indices->size(); if(!size) return 0; // set up bitmap MiscLib::Vector< std::pair< float, float > > extParams; BuildBitmap(pc, &epsilon, indices->begin(), indices->end(), &bitmapInfo.params, &bitmapInfo.bbox, &bitmapInfo.bitmap, &bitmapInfo.uextent, &bitmapInfo.vextent, &bitmapInfo.bmpIdx); /*static int fname_int = 0; std::ostringstream fn; fn << "bitmapImg" << fname_int++ << ".txt"; std::ofstream file; file.open(fn.str().c_str(), std::ios::out); for(size_t j = 0; j < vextent; ++j) { for(size_t i = 0; i < uextent; ++i) file << bitmap[j * uextent + i]; file << std::endl; } file.close();*/ // do a wrapping by copying pixels PreWrapBitmap(bitmapInfo.bbox, epsilon, bitmapInfo.uextent, bitmapInfo.vextent, &bitmapInfo.bitmap); MiscLib::Vector< char > tempBmp(bitmapInfo.bitmap.size()); // temporary bitmap object bool uwrap, vwrap; WrapBitmap(bitmapInfo.bbox, epsilon, &uwrap, &vwrap); if (doFiltering) { // closing DilateCross(bitmapInfo.bitmap, bitmapInfo.uextent, bitmapInfo.vextent, uwrap, vwrap, &tempBmp); ErodeCross(tempBmp, bitmapInfo.uextent, bitmapInfo.vextent, uwrap, vwrap, &bitmapInfo.bitmap); // opening //ErodeCross(bitmap, uextent, vextent, uwrap, vwrap, &tempBmp); //DilateCross(tempBmp, uextent, vextent, uwrap, vwrap, &bitmap); } Components(bitmapInfo.bitmap, bitmapInfo.uextent, bitmapInfo.vextent, uwrap, vwrap, &componentsImg, &labels); if(labels.size() <= 1) // found no connected component! { return 0; // associate no points with this shape } WrapComponents(bitmapInfo.bbox, epsilon, bitmapInfo.uextent, bitmapInfo.vextent, &componentsImg, &labels); return labels.size(); }
void ModalListPicker::LBSelChangedSlot(const ListBox::SelectionSet& rows) { if (rows.empty()) { SignalChanged(m_lb_wnd->end()); } else { auto sel_it = *rows.begin(); SignalChanged(sel_it); } }
void GroupTree::deepCopy(std::shared_ptr< GroupTreeNode > origin, std::shared_ptr< GroupTreeNode > copy) const { std::map<std::string, std::shared_ptr< GroupTreeNode > >::const_iterator iter = origin->begin(); while (iter != origin->end()) { std::shared_ptr< GroupTreeNode > originChild = (*iter).second; std::shared_ptr< GroupTreeNode > copyChild = copy->addChildGroup(originChild->name()); deepCopy(originChild, copyChild); ++iter; } }
void buildMap() { for(auto it = file->begin(); it != file->end(); it++) { std::stringstream ss(*it); std::string item; while(std::getline(ss, item, ' ')) { size_type lineNumber = it - file->begin(); (*map)[item].insert(lineNumber); } } }
void GroupTree::printTree(std::ostream &os , std::shared_ptr< GroupTreeNode > fromNode) const { os << fromNode->name() << "(" << fromNode.get() << ")"; std::map<std::string, std::shared_ptr< GroupTreeNode > >::const_iterator iter = fromNode->begin(); while (iter != fromNode->end()) { const auto& child = (*iter).second; os << "<-" << child->name() << "(" << child.get() << ")" << std::endl; printTree(os , child); ++iter; } }
void print_local(madness::World& world, const std::shared_ptr<TiledArray::Pmap>& pmap) { for(ProcessID r = 0; r < world.size(); ++r) { world.gop.fence(); if(r == world.rank()) { std::cout << r << ": { "; for(TiledArray::Pmap::const_iterator it = pmap->begin(); it != pmap->end(); ++it) std::cout << *it << " "; std::cout << "}\n"; } } }
void Entropy::setFin(std::shared_ptr< const std::map<int, int> > ptr_fin_map) { fin.clear(); n = 0; for ( auto it = ptr_fin_map->begin(); it != ptr_fin_map->end(); ++it ) { int freq = it->first, cnt = it->second; fin.push_back( std::make_pair( freq, cnt ) ); n += (freq * cnt); } }
void set_value(const std::shared_ptr<pj::object> &cfg, const char *part, const char* key, const pj::value &val) { if (cfg->find(part) == cfg->end()) { pj::object temp; cfg->insert({ part, pj::value(temp) }); } pj::object o = cfg->at(part).get<pj::object>(); o[key] = val; (*cfg.get())[part] = pj::value(o); }
std::shared_ptr<pj::value> find_value(const std::shared_ptr<pj::object> &cfg, const char *part, const char* key) { if (cfg->find(part) == cfg->end()) { return nullptr; } pj::value v = cfg->at(part); if (!v.is<pj::object>()) { return nullptr; } pj::object o = v.get<pj::object>(); if (o.find(key) == o.end()) { return nullptr; } return std::make_shared<pj::value>(o.at(key)); }
ResultF memoize_recursive_helper(const F f, std::shared_ptr<Cache> storage) { return [f, storage](FIn2 x) { const auto it = storage->find(x); if (it == storage->end()) { const auto g = memoize_recursive_helper(f, storage); (*storage)[x] = internal::invoke(f, g, x); } return (*storage)[x]; }; }
playlist HlsParser::CreateSinglePlaylist(std::shared_ptr<std::vector<TAG>> tag,std::string playlisturldir) { playlist tmpplaylist = { 0, 0, playlisttype::VOD}; std::vector<TAG>::iterator playlisttagitr = tag->begin(); for (; playlisttagitr != tag->end(); playlisttagitr++) { switch (playlisttagitr->tagname) { case TAG_EXT_X_TARGETDURATTION: { tmpplaylist.targetduration = atoi(playlisttagitr->tagvalue.c_str()); }break; case TAG_EXT_X_MEDIA_SEQUENCE: { tmpplaylist.sequenceid = atoi(playlisttagitr->tagvalue.c_str()); }break; case TAG_EXT_X_PLAYLIST_TYPE: { if (playlisttagitr->tagvalue == "VOD") { tmpplaylist.type = playlisttype::VOD; } else if (playlisttagitr->tagvalue == "LIVE") { tmpplaylist.type = playlisttype::LIVE; } }break; case TAG_EXTINF: { chunk tmpchunk; int pos = playlisttagitr->tagvalue.find(','); tmpchunk.chunkduration = atof(playlisttagitr->tagvalue.substr(0,pos).c_str()); tmpplaylist.chunklist.push_back(tmpchunk); }break; case TAG_EXT_X_BYTERANGE: { int pos = playlisttagitr->tagvalue.find('@'); tmpplaylist.chunklist.back().byterange_low = atoi(playlisttagitr->tagvalue.substr(pos + 1).c_str()); tmpplaylist.chunklist.back().byterange_up = atoi(playlisttagitr->tagvalue.substr(0, pos).c_str()) + tmpplaylist.chunklist.back().byterange_low; }break; default: { }break; } if (!playlisttagitr->tagurl.empty()) { tmpplaylist.chunklist.back().url = playlisturldir + playlisttagitr->tagurl; } } return tmpplaylist; }
std::unordered_map<std::string, std::vector<Feature>> FeatureIndex::lookupSymbolFeatures(const std::vector<IndexedSubfeature>& symbolFeatures, const RenderedQueryOptions& queryOptions, const std::vector<const RenderLayer*>& layers, const OverscaledTileID& tileID, const std::shared_ptr<std::vector<size_t>>& featureSortOrder) const { std::unordered_map<std::string, std::vector<Feature>> result; if (!tileData) { return result; } std::vector<IndexedSubfeature> sortedFeatures(symbolFeatures.begin(), symbolFeatures.end()); std::sort(sortedFeatures.begin(), sortedFeatures.end(), [featureSortOrder](const IndexedSubfeature& a, const IndexedSubfeature& b) { // Same idea as the non-symbol sort order, but symbol features may have changed their sort order // since their corresponding IndexedSubfeature was added to the CollisionIndex // The 'featureSortOrder' is relatively inefficient for querying but cheap to build on every bucket sort if (featureSortOrder) { // queryRenderedSymbols documentation says we'll return features in // "top-to-bottom" rendering order (aka last-to-first). // Actually there can be multiple symbol instances per feature, so // we sort each feature based on the first matching symbol instance. auto sortedA = std::find(featureSortOrder->begin(), featureSortOrder->end(), a.index); auto sortedB = std::find(featureSortOrder->begin(), featureSortOrder->end(), b.index); assert(sortedA != featureSortOrder->end()); assert(sortedB != featureSortOrder->end()); return sortedA > sortedB; } else { // Bucket hasn't been re-sorted based on angle, so use same "reverse of appearance in source data" // logic as non-symboles return a.sortIndex > b.sortIndex; } }); for (const auto& symbolFeature : sortedFeatures) { mat4 unusedMatrix; addFeature(result, symbolFeature, queryOptions, tileID.canonical, layers, GeometryCoordinates(), {}, 0, unusedMatrix); } return result; }
static std::shared_ptr< std::vector<int> > getVectOfIndex(std::shared_ptr< std::vector<T> >& input, std::shared_ptr<std::vector<T> >& keys){ if (std::is_fundamental<T>::value){ std::shared_ptr< std::vector<int> > indexVecPtr = std::make_shared< std::vector<int> >(); std::for_each(keys->begin(), keys->end(), [&](T& element) -> void{ int element_index = BinarySearchNumbers::getElementIndex(input, element); indexVecPtr->push_back(element_index); }); return indexVecPtr; }else return nullptr; };
void TransMult::applyMULTFLT( std::shared_ptr<const Fault> fault) { double transMult = fault->getTransMult(); for (auto face_iter = fault->begin(); face_iter != fault->end(); ++face_iter) { std::shared_ptr<const FaultFace> face = *face_iter; FaceDir::DirEnum faceDir = face->getDir(); std::shared_ptr<GridProperty<double> > multProperty = getDirectionProperty(faceDir); for (auto cell_iter = face->begin(); cell_iter != face->end(); ++cell_iter) { size_t globalIndex = *cell_iter; multProperty->multiplyValueAtIndex( globalIndex , transMult); } } }
cache_iterator_type get_initial_data(const double& x) const { cache_iterator_type after(cache_->lower_bound(x)); if (after == cache_->begin()) return after; if (after == cache_->end()) return --cache_iterator_type(after); cache_iterator_type before(after); --before; return abs(before->first - x) < abs(after->first - x) ? before : after; }