std::pair<iterator, bool>
insert (const value_type& x) {
if (x.first < x.second) {
if (empty ()) {
return m_set.insert (x);
}
iterator pos = find_first_touch (x);
if (pos == end ()) {
//nothing intersects x
return m_set.insert (x);
}
const Key alpha = std::min (x.first, pos->first);
Key beta = pos->second;
while (pos != m_set.end () && touch (*pos, x)) {
beta = pos->second;
m_set.erase (pos++);
}
beta = std::max (beta, x.second);
return m_set.insert (std::make_pair (alpha, beta));
}
return std::make_pair (m_set.end (), false);
}
inline std::pair<Observer::iterator, bool>
Observer::registerWith(const ext::shared_ptr<Observable>& h) {
if (h) {
h->registerObserver(this);
return observables_.insert(h);
}
return std::make_pair(observables_.end(), false);
}
//-----------------------------------------------------------------//
bool erase(handle_type h) {
if(h > 0 && h < limit_) {
set_it it = erase_set_.find(h);
if(it == erase_set_.end()) {
erase_set_.insert(h);
return true;
}
}
return false;
}
//-----------------------------------------------------------------//
bool erase(handle_type h) {
if(static_cast<size_t>(h) < size()) {
set_it it = erase_set_.find(h);
if(it == erase_set_.end()) {
erase_set_.insert(h);
return true;
}
}
return false;
}
int check_node(int x, int y, int z, MapData * map, int destroy)
{
if (nodes == NULL) {
nodes = (Position*)malloc(sizeof(Position) * NODE_RESERVE_SIZE);
nodes_size = NODE_RESERVE_SIZE;
}
node_pos = 0;
push_back_node(x, y, z);
while (node_pos > 0) {
if (node_pos >= nodes_size - 6) {
nodes_size += NODE_RESERVE_SIZE;
nodes = (Position*)realloc((void*)nodes,
sizeof(Position) * nodes_size);
}
const Position * current_node = pop_back_node();
z = current_node->z;
if (z >= 62) {
marked.clear();
return 1;
}
x = current_node->x;
y = current_node->y;
int i = get_pos(x, y, z);
// already visited?
pair<set_type<int>::iterator, bool> ret;
ret = marked.insert(i);
if (ret.second) {
add_node(x, y, z - 1, map);
add_node(x, y - 1, z, map);
add_node(x, y + 1, z, map);
add_node(x - 1, y, z, map);
add_node(x + 1, y, z, map);
add_node(x, y, z + 1, map);
}
}
// destroy the node's path!
if (destroy) {
for (set_type<int>::const_iterator iter = marked.begin();
iter != marked.end(); ++iter)
{
map->geometry[*iter] = 0;
map->colors.erase(*iter);
}
}
marked.clear();
return 0;
}
inline std::pair<Observer::iterator, bool>
Observer::registerWith(const ext::shared_ptr<Observable>& h) {
boost::lock_guard<boost::recursive_mutex> lock(mutex_);
if (!proxy_) {
proxy_.reset(new Proxy(this));
}
if (h) {
h->registerObserver(proxy_);
return observables_.insert(h);
}
return std::make_pair(observables_.end(), false);
}
// Let an object register its existence
void
object_registrar::register_object_imp
(
object_id obj
)
{
if ( db_.count(obj) <= 0 )
{
db_.insert( obj );
#if CONTROL_EXTRA_PRINTING
std::cout << "Registered " << obj << '.' << std::endl;
#endif
}
else
{
overeager_.push_back( obj );
#if CONTROL_EXTRA_PRINTING
std::cout << "Attempted to register a non-existant " << obj
<< '.' << std::endl;
#endif
}
}
inline void ObservableSettings::registerDeferredObservers(
const Observable::set_type& observers) {
deferredObservers_.insert(observers.begin(), observers.end());
}
inline void ObservableSettings::registerDeferredObservers(
const boost::unordered_set<Observer*>& observers) {
if (updatesDeferred()) {
deferredObservers_.insert(observers.begin(), observers.end());
}
}
