inline void ObservableSettings::registerDeferredObservers(
     const Observable::set_type& observers) {
     deferredObservers_.insert(observers.begin(), observers.end());
 }

 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;
 }

  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
    }
}

		//-----------------------------------------------------------------//
		void clear() {
			erase_set_.clear();
			array_.clear();
			if(zero_handle_enable_) array_.push_back(T());
		}

 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);
 }

 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 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 ();
 }