int map_unset(map_t map, void *key, void **olddata) { bucket_t *b, *prev; int hash; if (!map || !key) return RETERROR(EINVAL, -1); hash = map->hashf(map->size, key); b = map->buckets[hash]; prev = 0; while (b) { if (!map->compf(key, b->key)) { if (prev) prev->next = b->next; else map->buckets[hash] = b->next; mem_init(olddata, b->data); map_bucket_free(map, b); return -- map->count;; } prev = b; b = b->next; } return RETERROR(ERANGE, -1); }
void go( bool construct ) { typedef std::pair<std::string,int> key_t; typedef std::map<key_t, int> map_t; static map_t map; key_t id = key_t( file, line ); map_t::iterator it = map.find( id ); if( construct ) { compiled = ( it != map.end() ); if( !compiled ) { static int list = 0; list++; map.insert( std::pair<key_t,int>( id, list) ); glNewList( list, GL_COMPILE ); } } else { int list = it->second; if( !compiled ) { glEndList(); //std::cout << "compiled list #" << list << std::endl; } //std::cout << "calling list #" << list << std::endl; glCallList( list ); } }
/** Mark an element as recently used. */ void touch (const key_type& k) { auto found (map_.find(k)); assert(found != map_.end()); if (found != map_.end()) list_.splice(list_.begin(), list_, found->second); }
boost::optional<mapped_type&> try_get (const key_type& k) const { auto found (map_.find(k)); if (found == map_.end()) return boost::optional<mapped_type&>(); return found->second->second; }
void init() { map_t::iterator it = gMap.find(mKey); if (it == gMap.end()) { throw std::runtime_error("uninitialized mongo_stream sink"); } mObject = it->second; }
~constants() { #ifndef NDEBUG for( map_t::const_iterator it = map.begin(); it != map.end(); ++it ) if( !used[ it->first ].as<bool>() ) fprintf( stdout, ( moon9::iostring() << "<moon9/play/constants.hpp> says: warning, unused constant '" << it->first << "'" << std::endl ).c_str() ); #endif }
/** Get an element from the cache without changing its age. */ mapped_type& get (const key_type& k) const { auto found (map_.find(k)); if (found == map_.end()) throw std::runtime_error("lru_cache::get: key not found"); return found->second->second; }
std::string debug( const moon9::iostring &head = moon9::iostring(), const moon9::iostring &format12 = "\t\1=\2\n", const moon9::iostring &footer = moon9::iostring() ) //const { moon9::iostring body; for( map_t::const_iterator it = map.begin(); it != map.end(); ++it ) body << moon9::iostring( format12, it->first, it->second ); return head + body + footer; }
boost::optional<mapped_type&> try_get (const key_type& k) { auto found (map_.find(k)); if (found == map_.end()) return boost::optional<mapped_type&>(); list_.splice(list_.begin(), list_, found->second); return found->second->second; }
/** Remove an element from the cache. */ void remove (const key_type& k) { auto found (map_.find(k)); if (found == map_.end()) return; list_.erase(found->second); map_.erase(found); --size_; }
void ModuleNcurses::display(map_t const & map) { uint x; if (werase(this->win) == ERR) throw Exception(strerror(errno)); for (uint y = 0; y != map.size() ; ++y) { for (x = 0; x != map.size() ; ++x) display_slot(x, y, map[y][x]); } if (wrefresh(this->win) == ERR) throw Exception(strerror(errno)); }
static void check_and_add_output_file(Module* NewMod, const std::string& str) { typedef std::map<std::string, Module*> map_t; static map_t files; map_t::iterator i = files.find(str); if (i != files.end()) { Module* ThisMod = i->second; error(Loc(), "Output file '%s' for module '%s' collides with previous module '%s'. See the -oq option", str.c_str(), NewMod->toPrettyChars(), ThisMod->toPrettyChars()); fatal(); } files.insert(std::make_pair(str, NewMod)); }
static std::uint32_t to(state_t &state, const map_t &map_val) { ::lua_createtable(state, (int)map_val.size(), (int)map_val.size()); std::for_each(map_val.cbegin(), map_val.cend(), [&state](const typename map_t::value_type &val) { convertion_t<typename map_t::key_type>::to(state, val.first); convertion_t<typename map_t::mapped_type>::to(state, val.second); ::lua_settable(state, -3); }); return map_val.size() == 0 ? 0 : 1; }
/** Fetch an element from the cache. * If the key does not exist yet, a new empty element will be * created. */ mapped_type& operator[] (const key_type& k) { auto found (map_.find(k)); if (found == map_.end()) { list_.push_front(pair_t(k, mapped_type())); map_[k] = list_.begin(); ++size_; return list_.begin()->second; } list_.splice(list_.begin(), list_, found->second); return found->second->second; }
const char* name_t::map_string(const char* str, std::size_t hash) { typedef std::unordered_map<std::size_t, const char*> map_t; typedef std::lock_guard<std::mutex> lock_t; static std::mutex sync_s; lock_t lock(sync_s); static adobe::unique_string_pool_t pool_s; static map_t map_s; map_t::const_iterator found(map_s.find(hash)); return found == map_s.end() ? map_s.emplace(hash, pool_s.add(str)).first->second : found->second; }
// has bool has(const KEY_T& key) const { if (find(key) != map->end()) { return true; } else { return false; } }
int map_set(map_t map, void *key, void *data, void **olddata) { bucket_t *b; if (!map || !key) return RETERROR(EINVAL, -1); b = map_bucket_find(map, key); if (b) { mem_init(olddata, b->data); b->data = data; } else { int hash; if (!map_resize(map, map->count + 1, 0)) return -1; if (!(b = map_bucket_alloc(map, key, data))) return -1; hash = map->hashf(map->size, key); b->next = map->buckets[hash]; map->buckets[hash] = b; ++ map->count; } return map->count; }
void ModuleOpenGL::display(map_t const & map) { uint x; uint y = 0; glClear(GL_COLOR_BUFFER_BIT); glViewport(0, 0, this->width, this->height); xglBegin(GL_QUADS); glColor3ub(51, 51, 51); glVertex2d(-1,-1); glVertex2d(-1,1); glColor3ub(30, 30, 30); glVertex2d(1,1); glVertex2d(1,-1); xglEnd(); for (std::vector<std::vector<slot_t> >::const_iterator it_y = map.begin(); it_y != map.end(); ++it_y) { x = 0; for (std::vector<slot_t>::const_iterator it_x = (*it_y).begin(); it_x != (*it_y).end(); ++it_x) { display_slot(x, y, (*it_x)); ++x; } ++y; } xglFlush(); SDL_GL_SwapBuffers(); }
// change std::pair<class map_t::const_iterator, bool> change(const KEY_T& key, const PAY_T& pay) { if (file_mode == READ_ONLY) { throw std::runtime_error("Error: change called in RO mode"); } // erase the old element size_t num_erased = erase(key); if (num_erased != 1) { // erase failed return std::pair<class map_t::const_iterator, bool>(map->end(), false); } else { // put in new return map->emplace(key, pay); } }
template <typename... IndexType> void insert(IndexType const&... ind) { map_index_n.insert({{ind...}, size()}); // reorder the indices which are always given in the order of the indices tuple map_t m; int i = 0; for (auto const& p : map_index_n) m.insert({p.first, i++}); std::swap(m, map_index_n); }
// insert std::pair<class map_t::const_iterator, bool> emplace(const KEY_T& key, const PAY_T& pay) { if (file_mode == READ_ONLY) { throw std::runtime_error("Error: emplace called in RO mode"); } return map->emplace(key, pay); }
// erase size_t erase(const KEY_T& key) { if (file_mode == READ_ONLY) { throw std::runtime_error("Error: erase called in RO mode"); } size_t num_erased = map->erase(key); return num_erased; }
/** Prune the cache back to a given size. * If the cache is larger than the maximum, the oldest entries * will be deleted. * @post size() <= max_size * @param max_size The maximum cache size */ void prune (size_t max_size) { while (size_ > max_size) { map_.erase(list_.back().first); list_.pop_back(); --size_; } }
//Returns a reference to the resource associated with the file name 'key' if it exists in memory. //Otherwise it loads the texture into memory, and returns a reference to the the resource. T &Load(key_type const &key) noexcept(false) { map_i i = m_map.find(key); if(i != m_map.end()) { return *i->second.get(); //return resource if exists } //else, load resource ptr_t p {onLoadResource(key)}; if(p.get() == NULL) { throw Exception(std::string("Error loading Image at ") + key); } m_map.insert(std::make_pair(key, std::move(p))); return *m_map[key].get(); }
void set_fields(doid_t do_id, const map_t &fields) { m_log->trace() << "Setting fields on obj-" << do_id << endl; YAML::Node document; if(!load(do_id, document)) { return; } // Get the fields from the file that are not being updated const Class* dcc = g_dcf->get_class_by_name(document["class"].as<string>()); ObjectData dbo(dcc->get_id()); YAML::Node existing = document["fields"]; for(auto it = existing.begin(); it != existing.end(); ++it) { const Field* field = dcc->get_field_by_name(it->first.as<string>()); if(!field) { m_log->warning() << "Field '" << it->first.as<string>() << "', loaded from '" << filename(do_id) << "', does not exist." << endl; continue; } auto found = fields.find(field); if(found == fields.end()) { vector<uint8_t> value = read_yaml_field(field, it->second, do_id); if(value.size() > 0) { dbo.fields[field] = value; } } } // Add in the fields that are being updated: for(auto it = fields.begin(); it != fields.end(); ++it) { dbo.fields[it->first] = it->second; } write_yaml_object(do_id, dcc, dbo); }
void prune (size_t max_size, func on_remove) { while (size_ > max_size) { pair_t& tbr (list_.back()); on_remove(tbr.first, tbr.second); map_.erase(tbr.first); list_.pop_back(); --size_; } }
void write() { static comma::csv::output_stream< interval_t< From, To > > ostream( std::cout, ocsv ); static comma::csv::ascii< from_t< std::string > > from_ascii( ascii_csv ); static comma::csv::ascii< to_t< std::string > > to_ascii( ascii_csv ); for( typename map_t::iterator it = map.begin(); it != map.end(); ++it ) { bound_t< bound_type > from = it->first.lower(); bound_t< bound_type > to = it->first.upper(); interval_t< From, To > interval; bool from_has_value = true; bool to_has_value = true; if( from.value ) { interval.from.value = *from.value; } else if( use_limits ) { interval.from.value = limits< From >::lowest(); } else if( empty ) { interval.from.value = static_cast< From >( *empty ); } else { from_has_value = false; } if( to.value ) { interval.to.value = *to.value; } else if( use_limits ) { interval.to.value = limits< To >::max(); } else if( empty ) { interval.to.value = static_cast< To >( *empty ); } else { to_has_value = false; } const set_t& s = it->second; if( csv.binary() ) { if( intervals_only ) { ostream.write( interval ); ostream.flush(); continue; } for( typename set_t::const_iterator v = s.begin(); v != s.end(); ++v ) { ostream.write( interval, *v ); } ostream.flush(); } else { for( typename set_t::const_iterator v = s.begin(); v != s.end(); ++v ) { std::string payload( intervals_only ? "" : *v ); ostream.ascii().ascii().put( interval, payload ); if( !from_has_value ) { from_ascii.put( from_t< std::string >(), payload ); } if( !to_has_value ) { to_ascii.put( to_t< std::string >(), payload); } std::cout << payload << std::endl; if( intervals_only ) { break; } } } } }
void ModuleSDL::display(map_t const & map) { uint x, y; int r; y = 0; r = SDL_FillRect(this->s_ecran, NULL, SDL_MapRGB(this->s_ecran->format, 0, 0, 0)); if (r == -1) throw Exception(SDL_GetError()); for (std::vector<std::vector<slot_t> >::const_iterator it_y = map.begin(); it_y != map.end(); ++it_y) { x = 0; for (std::vector<slot_t>::const_iterator it_x = (*it_y).begin(); it_x != (*it_y).end(); ++it_x) { display_slot(x, y, (*it_x)); ++x; } ++y; } r = SDL_Flip(this->s_ecran); if (r == -1) throw Exception(SDL_GetError()); }
void prune_if (size_t max_size, pred op) { if (list_.empty()) return; auto i (std::prev(list_.end())); while (size_ > max_size) { if (op(*i)) { map_.erase(i->first); i = list_.erase(i); --size_; } if (i == list_.begin()) return; --i; } }
inline void insertEmptyNodePtr(map_t& map, hash_t key) { map.put(key, unique_ptr<Node>(new Node{})); }