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 Observer& Observer::operator=(const Observer& o) {
iterator i;
for (i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(this);
observables_ = o.observables_;
for (i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->registerObserver(this);
return *this;
}
size_type erase (const key_type& k) {
if (k.first < k.second) {
if (empty ()) {
return 0;
}
iterator pos = find_first_intersect (k);
if (pos == end ()) {
return 0;
}
const Key alpha = pos->first;
const Key beta = std::min (pos->second, k.first);
Key delta = pos->second;
size_type count = 0;
while (pos != m_set.end () && intersect (*pos, k)) {
delta = pos->second;
m_set.erase (pos++);
++count;
}
insert (std::make_pair (alpha, beta));
insert (std::make_pair (k.second, delta));
return count;
}
return 0;
}
//-----------------------------------------------------------------//
inline bool probe(handle_type h) const {
if(static_cast<size_t>(h) < size()) {
return erase_set_.find(h) == erase_set_.end();
} else {
return false;
}
}
inline void ObservableSettings::enableUpdates() {
boost::lock_guard<boost::mutex> lock(mutex_);
// if there are outstanding deferred updates, do the notification
updatesType_ = UpdatesEnabled;
if (deferredObservers_.size()) {
bool successful = true;
std::string errMsg;
for (iterator i=deferredObservers_.begin();
i!=deferredObservers_.end(); ++i) {
try {
const ext::shared_ptr<Observer::Proxy> proxy = i->lock();
if (proxy)
proxy->update();
} catch (std::exception& e) {
successful = false;
errMsg = e.what();
} catch (...) {
successful = false;
}
}
deferredObservers_.clear();
QL_ENSURE(successful,
"could not notify one or more observers: " << errMsg);
}
}
//-----------------------------------------------------------------//
bool probe(handle_type h) const {
if(h > 0 && h < limit_) {
return erase_set_.find(h) == erase_set_.end();
} else {
return false;
}
}
// Let an object un-register its existence
void
object_registrar::unregister_object_imp
(
object_id obj
)
{
set_type::iterator const i = db_.find( obj );
if ( i != db_.end() )
{
db_.erase( i );
#if CONTROL_EXTRA_PRINTING
std::cout << "Unregistered " << obj << '.' << std::endl;
#endif
}
else
{
overkilled_.push_back( obj );
#if CONTROL_EXTRA_PRINTING
std::cout << "Attempted to unregister a non-existant " << obj
<< '.' << std::endl;
#endif
}
}
inline void Observer::unregisterWithAll() {
boost::lock_guard<boost::recursive_mutex> lock(mutex_);
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(proxy_);
observables_.clear();
}
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);
}
inline Observer::~Observer() {
boost::lock_guard<boost::recursive_mutex> lock(mutex_);
if (proxy_)
proxy_->deactivate();
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(proxy_);
}
powerset_type powerset(set_type const& set)
{
typedef set_type::const_iterator set_iter;
typedef std::vector<set_iter> vec;
typedef vec::iterator vec_iter;
struct local
{
static int dereference(set_iter v) { return *v; }
};
powerset_type result;
vec elements;
do
{
set_type tmp;
std::transform(elements.begin(), elements.end(),
std::inserter(tmp, tmp.end()),
local::dereference);
result.insert(tmp);
if (!elements.empty() && ++elements.back() == set.end())
{
elements.pop_back();
}
else
{
set_iter iter;
if (elements.empty())
{
iter = set.begin();
}
else
{
iter = elements.back();
++iter;
}
for (; iter != set.end(); ++iter)
{
elements.push_back(iter);
}
}
} while (!elements.empty());
return result;
}
inline Observer& Observer::operator=(const Observer& o) {
boost::lock_guard<boost::recursive_mutex> lock(mutex_);
if (!proxy_) {
proxy_.reset(new Proxy(this));
}
iterator i;
for (i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(proxy_);
{
boost::lock_guard<boost::recursive_mutex> lock(o.mutex_);
observables_ = o.observables_;
}
for (i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->registerObserver(proxy_);
return *this;
}
//-----------------------------------------------------------------//
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;
}
//-----------------------------------------------------------------//
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;
}
inline Observer::Observer(const Observer& o) {
proxy_.reset(new Proxy(this));
{
boost::lock_guard<boost::recursive_mutex> lock(o.mutex_);
observables_ = o.observables_;
}
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->registerObserver(proxy_);
}
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);
}
void printSet(set_type s) {
for (typename set_type::iterator p = s.begin(); p != s.end(); p++)
cout << *p << ' ';
cout << endl;
}
bool disjoint(const set_type& a, const set_type& b) {
counting_output_iterator out;
return std::set_intersection(a.begin(), a.end(),
b.begin(), b.end(), out).count() == 0;
}
inline void Observer::unregisterWithAll() {
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(this);
observables_.clear();
}
inline Observer::~Observer() {
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(this);
}
inline Observer::Observer(const Observer& o)
: observables_(o.observables_) {
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->registerObserver(this);
}
iterator end () const {
return m_set.end ();
}
