void move_close_to(vid_t v) { if (curvid >= v) return; std::map<int,indexentry>::iterator lowerbd_iter = sparse_index.lower_bound(-((int)v)); int closest_vid = -((int)lowerbd_iter->first); assert(closest_vid>=0); indexentry closest_offset = lowerbd_iter->second; assert(closest_vid <= (int)v); if (closest_vid > (int)curvid) { /* Note: this will fail if we have over 2B vertices! */ logstream(LOG_DEBUG) << "Sliding shard, start: " << range_st << " moved to: " << closest_vid << " " << closest_offset.adjoffset << ", asked for : " << v << " was in: curvid= " << curvid << " " << adjoffset << std::endl; if (curblock != NULL) // Move the pointer - this may invalidate the curblock, but it is being checked later curblock->ptr += closest_offset.edataoffset - edataoffset; if (curadjblock != NULL) curadjblock->ptr += closest_offset.adjoffset - adjoffset; curvid = (vid_t)closest_vid; adjoffset = closest_offset.adjoffset; edataoffset = closest_offset.edataoffset; return; } else { // Do nothing - just continue from current pos. return; } }
std::map<u32,DisassemblyEntry*>::iterator findDisassemblyEntry(std::map<u32,DisassemblyEntry*>& entries, u32 address, bool exact) { if (exact) return entries.find(address); if (entries.size() == 0) return entries.end(); // find first elem that's >= address auto it = entries.lower_bound(address); if (it != entries.end()) { // it may be an exact match if (isInInterval(it->second->getLineAddress(0),it->second->getTotalSize(),address)) return it; // otherwise it may point to the next if (it != entries.begin()) { it--; if (isInInterval(it->second->getLineAddress(0),it->second->getTotalSize(),address)) return it; } } // check last entry manually auto rit = entries.rbegin(); if (isInInterval(rit->second->getLineAddress(0),rit->second->getTotalSize(),address)) { return (++rit).base(); } // no match otherwise return entries.end(); }
const char * AbiWordperfectInputStream::subStreamName(unsigned id) { if (!m_ole) m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL)); if (!m_ole) m_ole = GSF_INFILE(gsf_infile_zip_new (m_input, NULL)); if (m_ole) { if ((int)id >= gsf_infile_num_children(m_ole)) { return 0; } std::map<unsigned, std::string>::iterator i = m_substreams.lower_bound(id); if (i == m_substreams.end() || m_substreams.key_comp()(id, i->first)) { std::string name = gsf_infile_name_by_index(m_ole, (int)id); i = m_substreams.insert(i, std::map<unsigned, std::string>::value_type(id, name)); } return i->second.c_str(); } return 0; }
// // Creates an iterator over a collection of ties represented by the // given map. The values of the pairs in the map represent the values // of ties, and the keys represent the corresponding neighbors. Only // neighbors that are greater or equal with the given bound are returned. // IncidentTieIterator::IncidentTieIterator(const std::map<int, int> & ties, int lowerBound) : ITieIterator(), // lstart(ties.lower_bound(lowerBound)), // lcurrent(lstart), // lend(ties.end()) { }
void __stdcall touring_Tier0_CMemAlloc_Free(DWORD * this_ptr, void *pMem) { if(pMem) { size_t size = SOURCESDK::Get_g_pMemAlloc()->GetSize(pMem); // Make sure GetSize is not called with 0 pointer! void * upperBound = (char *)pMem + size; std::unique_lock<std::mutex> lock(g_Tier0MemAllocFreeNotifyeesMutex); for (std::map<void *, CTier0MemAllocFreeNotifyees>::iterator it = g_Tier0MemAllocFreeNotifyees.lower_bound(pMem); it != g_Tier0MemAllocFreeNotifyees.end(); ) { if (it->first < upperBound) { it->second.Notify(it->first); std::map<void *, CTier0MemAllocFreeNotifyees>::iterator itErase = it; ++it; g_Tier0MemAllocFreeNotifyees.erase(itErase); } else break; } } g_Tier0_CMemAlloc_Free(this_ptr, pMem); }
InstrInfo get(uint32_t address) { auto info = InstrInfo { 0 }; auto instrIter = sInstrData.find(address); if (instrIter != sInstrData.end()) { info.instr = &instrIter->second; } if (sFuncData.size() > 0) { auto funcIter = sFuncData.lower_bound(address); auto &func = funcIter->second; if (address >= func.start && address < func.end) { // The function needs to have an end, or be the first two instructions // since we apply some special display logic to the first two instructions // in a never-ending function... if (func.end != 0xFFFFFFFF || (address == func.start || address == func.start + 4)) { info.func = &func; } } } return info; }
void OKSocialPluginAndroid::getMyProfile(int preferedPictureSize, void *userData, const std::vector<std::string> &additionalFields) { if (!isLoggedIn()) { if (_delegate) _delegate->onGetMyProfile({SocialPluginDelegate::Error::Type::NO_LOGIN, 0, ""}, userData, _emptyProfile); return; } std::string fields = "uid,first_name,last_name,email,birthday,gender"; for (const auto &field : additionalFields) fields += "," + field; auto picturesMapIterator = _picturesMap.lower_bound(preferedPictureSize); const auto &pictureField = (picturesMapIterator == _picturesMap.end()) ? _picturesMap.rbegin()->second : picturesMapIterator->second; fields += "," + _pictureIDKey + "," + pictureField; cocos2d::JniMethodInfo methodInfo; if (cocos2d::JniHelper::getStaticMethodInfo(methodInfo, HELPER_CLASS_NAME, "getMyProfile", "(Ljava/lang/String;JLjava/lang/String;Z)V")) { jstring jFields = methodInfo.env->NewStringUTF(fields.c_str()); jstring jPictureField = methodInfo.env->NewStringUTF(pictureField.c_str()); methodInfo.env->CallStaticVoidMethod(methodInfo.classID, methodInfo.methodID, jFields, (jlong)userData, jPictureField, (jboolean)_debug); methodInfo.env->DeleteLocalRef(methodInfo.classID); // methodInfo.env->DeleteLocalRef(jFields); // TODO // methodInfo.env->DeleteLocalRef(jPictureField); // TODO } }
template<typename T> void mergeInto(std::map<unsigned, std::vector<T>>& _container, unsigned _number, T&& _data) { assert(!haveItem(_container, _number)); auto lower = _container.lower_bound(_number); if (!_container.empty() && lower != _container.begin()) --lower; if (lower != _container.end() && (lower->first + lower->second.size() == _number)) { // extend existing chunk lower->second.emplace_back(_data); auto next = lower; ++next; if (next != _container.end() && (lower->first + lower->second.size() == next->first)) { // merge with the next chunk std::move(next->second.begin(), next->second.end(), std::back_inserter(lower->second)); _container.erase(next); } } else { // insert a new chunk auto inserted = _container.insert(lower, std::make_pair(_number, std::vector<T> { _data })); auto next = inserted; ++next; if (next != _container.end() && next->first == _number + 1) { std::move(next->second.begin(), next->second.end(), std::back_inserter(inserted->second)); _container.erase(next); } } }
// Assign value val to interval [keyBegin, keyEnd). // Overwrite previous values in this interval. // Do not change values outside this interval. // Conforming to the C++ Standard Library conventions, the interval // includes keyBegin, but excludes keyEnd. // If !( keyBegin < keyEnd ), this designates an empty interval, // and assign must do nothing. void assign( K const& keyBegin, K const& keyEnd, const V& val) { using iter_t = std::map<K, V>::const_iterator; if (!(keyBegin < keyEnd)) return; const iter_t lower_bound = map_.lower_bound(keyBegin); const iter_t upper_bound = map_.upper_bound(keyEnd); const iter_t prev = std::prev(lower_bound); const iter_t next = std::prev(upper_bound); // erase elements in range [lower_bound, upper_bound) map_.erase(lower_bound, upper_bound); if (!(prev->second == val)) { // set new value at the beginning of the range map_.insert(upper_bound, std::make_pair(keyBegin, val)); } if (!(next->second == val)) { // set next value at the end of the range map_.insert(upper_bound, std::make_pair(keyEnd, next->second)); } }
unsigned int TxConfirmStats::NewTx(unsigned int nBlockHeight, double val) { unsigned int bucketindex = bucketMap.lower_bound(val)->second; unsigned int blockIndex = nBlockHeight % unconfTxs.size(); unconfTxs[blockIndex][bucketindex]++; return bucketindex; }
void LogMonitorHandler::remove_expired_keys(std::map<time_t, StatInfo> &m, time_t expired_time) { std::map<time_t, StatInfo>::iterator e_index = m.lower_bound(expired_time); if (e_index != m.begin()) { m.erase(m.begin(), e_index); LOG_DEBUG("has expired record is remove!"); } }
GlobalOrdinal find_row_for_id(GlobalOrdinal id, const std::map<GlobalOrdinal,GlobalOrdinal>& ids_to_rows) { typename std::map<GlobalOrdinal,GlobalOrdinal>::const_iterator iter = ids_to_rows.lower_bound(id); if (iter == ids_to_rows.end() || iter->first != id) { if (ids_to_rows.size() > 0) { --iter; } else { std::cout << "ERROR, failed to map id to row."<<std::endl; return -99; } } if (iter->first == id) { return iter->second; } if (iter == ids_to_rows.begin() && iter->first > id) { std::cout << "ERROR, id:" << id << ", ids_to_rows.begin(): " << iter->first<<std::endl; return -99; } GlobalOrdinal offset = id - iter->first; if (offset < 0) { std::cout << "ERROR, negative offset in find_row_for_id for id="<<id<<std::endl; return -99; } return iter->second + offset; }
CTransactionRef RandomOrphan() { std::map<uint256, COrphanTx>::iterator it; it = mapOrphanTransactions.lower_bound(GetRandHash()); if (it == mapOrphanTransactions.end()) it = mapOrphanTransactions.begin(); return it->second.tx; }
static const T &load(const std::string &resourceName, Args... args){ typename std::map<std::string, T>::iterator p = _resources.lower_bound(resourceName); if(p == _resources.end() || p->first != resourceName){ cout<<"WARNING: Resource: "+resourceName+" not found. Loading..."<<endl; p = _resources.emplace_hint(p, std::piecewise_construct, std::forward_as_tuple(resourceName), std::forward_as_tuple(args...)); } return p->second; }
CTransactionRef RandomOrphan() { std::map<uint256, COrphanTx>::iterator it; LOCK(cs_main); it = mapOrphanTransactions.lower_bound(InsecureRand256()); if (it == mapOrphanTransactions.end()) it = mapOrphanTransactions.begin(); return it->second.tx; }
bool is_dummy_address (void *addr) { intptr_t ip = intptr_t (addr); auto it = absptrmap.lower_bound (ip+1); if (it == absptrmap.end()) return false; intptr_t lb = it->first; intptr_t ub = it->second; return (ip >= lb && ip < ub); }
char * findPtrForSize(size_t size) { auto it = freeSize.lower_bound(size); if(it != freeSize.end()) { assert(it->second.empty() == false); return *(it->second.begin()); } return NULL; }
/////////////////////// /// Devuelve el recurso asociado con el nombre, si no está trata de crearlo usando un constructor por defecto e inicializarlo luego llamando a la funcion f con los parametros args ////////////////////// static const T &loadFromFile(const std::string &fileName){ typename std::map<std::string, T>::iterator p = _resources.lower_bound(fileName); if(p == _resources.end() || p->first != fileName){ p = _resources.emplace_hint(p, std::piecewise_construct, std::forward_as_tuple(fileName), std::forward_as_tuple()); if(!p->second.loadFromFile(fileName)){ cout<<"ERROR: Couldn't load file: "<<fileName<<endl; } } return p->second; }
static inline void increaseColorUsage(uint32_t color, uint32_t usageCount, std::map<uint32_t, uint32_t> & colorUsage) { auto lb = colorUsage.lower_bound(color); if (lb != colorUsage.end() && !(colorUsage.key_comp()(color, lb->first))) { // Color already in map. lb->second += usageCount; } else { // Insert new color into map. colorUsage.insert(lb, std::make_pair(color, usageCount)); } }
void LogMonitorHandler::get_range_map(std::map<time_t, StatInfo> & origin_map, std::map<time_t, StatInfo> & stat_map, time_t start, time_t end) { std::map<time_t, StatInfo>::iterator start_iter = origin_map.lower_bound(start); while(start_iter != origin_map.end()){ if (start_iter->first >= end) { break; } stat_map[start_iter->first] = start_iter->second; start_iter++; } }
Individual<Phenotype, Genotype> mutate(Individual<Phenotype, Genotype> i, const Codec<Phenotype, Genotype>& codec) override { float p = distribution_(generator_); auto it = mutations_.lower_bound(p); if (it == mutations_.end()){ it = mutations_.begin(); } MutationPtr& mutation = it->second; return std::move(mutation->mutate(std::move(i), codec)); }
template<typename T> bool haveItem(std::map<unsigned, T>& _container, unsigned _number) { if (_container.empty()) return false; auto lower = _container.lower_bound(_number); if (lower != _container.end() && lower->first == _number) return true; if (lower == _container.begin()) return false; --lower; return lower->first <= _number && (lower->first + lower->second.size()) > _number; }
static std::pair< std::map< std::string, std::vector<const TestFactory*> >::const_iterator, std::map< std::string, std::vector<const TestFactory*> >::const_iterator > matching_range( const std::map< std::string, std::vector<const TestFactory*> > & tests, const std::string & group ) { assert( !group.empty() ); assert( *group.rbegin() == '/' ); std::map< std::string, std::vector<const TestFactory*> >::const_iterator b, e; e = b = tests.lower_bound( group ); while ( e != tests.end() && e->first.find( group ) == 0 ) ++e; return std::make_pair( b, e ); }
void TxConfirmStats::Record(int blocksToConfirm, double val) { // blocksToConfirm is 1-based if (blocksToConfirm < 1) return; unsigned int bucketindex = bucketMap.lower_bound(val)->second; for (size_t i = blocksToConfirm; i <= curBlockConf.size(); i++) { curBlockConf[i - 1][bucketindex]++; } curBlockTxCt[bucketindex]++; curBlockVal[bucketindex] += val; }
float VSRayTracingVisitor::interpolate(const std::map<unsigned, float>& data, float x) { std::map<unsigned, float>::const_iterator itr = data.lower_bound((unsigned)x); float x2 = itr->first; float y2 = itr->second; --itr; float x1 = itr->first; float y1 = itr->second; return y1 + (x-x1)*(y2-y1)/(x2-x1); }
/** * Send all inventory items that are not known to c and are dated 'after' */ void handle_get_inv( const connection_ptr& c, bitchat_chan_data& cd, const get_inv_message& msg ) { inv_message reply; for( auto itr = msg_time_index.lower_bound( fc::time_point(msg.after) ); itr != msg_time_index.end(); ++itr ) { if( cd.known_inv.insert( itr->second ).second ) { reply.items.push_back( itr->second ); cd.known_inv.insert( itr->second ); } } c->send( network::message( reply, chan_id ) ); }
unsigned getOrCreateDiagID(DiagnosticIDs::Level L, StringRef Message, DiagnosticIDs &Diags) { DiagDesc D(L, Message); // Check to see if it already exists. std::map<DiagDesc, unsigned>::iterator I = DiagIDs.lower_bound(D); if (I != DiagIDs.end() && I->first == D) return I->second; // If not, assign a new ID. unsigned ID = DiagInfo.size()+DIAG_UPPER_LIMIT; DiagIDs.insert(std::make_pair(D, ID)); DiagInfo.push_back(D); return ID; }
template<typename T> void removeItem(std::map<unsigned, std::vector<T>>& _container, unsigned _number) { if (_container.empty()) return; auto lower = _container.lower_bound(_number); if (lower != _container.end() && lower->first == _number) { _container.erase(lower); return; } if (lower == _container.begin()) return; --lower; if (lower->first <= _number && (lower->first + lower->second.size()) > _number) lower->second.erase(lower->second.begin() + (_number - lower->first), lower->second.end()); }
void addNum(int val) { auto it = map.lower_bound(val); if (it == map.end()) { if (!map.empty()) { auto prev_it = it; prev_it--; if (prev_it->second >= val) { return; } else if (prev_it->second == val - 1) { prev_it->second = val; return; } } map[val] = val; } else if (it == map.begin()) { if (it->first == val) { return; } else if (it->first == val + 1) { map[val] = it->second; map.erase(val + 1); } else { map[val] = val; } } else { auto prev_it = it; prev_it--; if (prev_it->second >= val || it->first == val) { return; } else if (prev_it->second == val - 1) { if (it->first == val + 1) { prev_it->second = it->second; map.erase(val + 1); } else { prev_it->second = val; } } else if (it->first == val + 1) { map[val] = it->second; map.erase(val + 1); } else { map[val] = val; } } }
inline std::map<K, V> operator>> (object o, std::map<K, V>& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); object_kv* const pend(o.via.map.ptr + o.via.map.size); for(; p != pend; ++p) { K key; p->key.convert(&key); typename std::map<K,V>::iterator it(v.lower_bound(key)); if(it != v.end() && !(key < it->first)) { p->val.convert(&it->second); } else { V val; p->val.convert(&val); v.insert(it, std::pair<K,V>(key, val)); } } return v; }