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);
}
// 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
}
}
// Let an object un-register its use of another object
void
object_registrar::unregister_use_imp
(
object_id owner,
object_id owned
)
{
if ( db_.count(owned) > 0 )
{
// We don't care to record usage un-registrations
}
else
{
defrauders_out_.push_back( std::make_pair(owner, owned) );
#if CONTROL_EXTRA_PRINTING
std::cout << "Attempted to disown a non-existant " << owned
<< " by " << owner << '.' << std::endl;
#endif
}
}
//-----------------------------------------------------------------//
void clear() {
erase_set_.clear();
array_.clear();
if(zero_handle_enable_) array_.push_back(T());
}
inline void ObservableSettings::registerDeferredObservers(
const Observable::set_type& observers) {
deferredObservers_.insert(observers.begin(), observers.end());
}
inline
Size Observer::unregisterWith(const ext::shared_ptr<Observable>& h) {
if (h)
h->unregisterObserver(this);
return observables_.erase(h);
}
inline Observer::Observer(const Observer& o)
: observables_(o.observables_) {
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->registerObserver(this);
}
inline void ObservableSettings::registerDeferredObservers(
const boost::unordered_set<Observer*>& observers) {
if (updatesDeferred()) {
deferredObservers_.insert(observers.begin(), observers.end());
}
}
bool empty () const {
return m_set.empty ();
}
size_type count (const key_type& k) const {
return m_set.count (k);
}
iterator find (const key_type& k) const {
return m_set.find (k);
}
void erase (iterator f, iterator l) {
m_set.erase (f, l);
}
void erase (iterator pos) {
m_set.erase (pos);
}
//-----------------------------------------------------------------//
void clear() {
erase_set_.clear();
current_ = start_;
}
//-----------------------------------------------------------------//
handle_type size() const { return current_ - 1 - erase_set_.size(); }
size_type size () const {
return m_set.size ();
}
size_type max_size () const {
return m_set.max_size ();
}
iterator lower_bound (const key_type& k) const {
return m_set.lower_bound (k);
}
void swap (interval_set& is) {
if (this != &is) {
m_set.swap (is.m_set);
}
}
iterator upper_bound (const key_type& k) const {
return m_set.upper_bound (k);
}
std::pair<iterator, iterator>
equal_range (const key_type& k) const {
return m_set.equal_range (k);
}
iterator begin () const {
return m_set.begin ();
}
inline void ObservableSettings::unregisterDeferredObserver(Observer* o) {
deferredObservers_.erase(o);
}
iterator end () const {
return m_set.end ();
}
inline Observer::~Observer() {
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(this);
}
reverse_iterator rbegin () const {
return m_set.rbegin ();
}
inline void Observer::unregisterWithAll() {
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(this);
observables_.clear();
}
reverse_iterator rend () const {
return m_set.rend ();
}
inline void ObservableSettings::unregisterDeferredObserver(
const ext::shared_ptr<Observer::Proxy>& o) {
deferredObservers_.erase(o);
}
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;
}
