Use callback idiom

• idiomRegister.cc:

  /*
      Test callback idiom. This is similar to what might be used 
      in caller-callee pattern, observer-observable pattern, etc.
      This uses RRefables as the observers, and a list of RRefs as
      the observers registered in the observable. 
      
      \author Oliver Schoenborn
      \since Apr 2003
  */
  
  
  #include <iostream>
  #include <list>
  #include <memory>
  #include "RRef.hh"
  #include "RRefable.hh"
  #include "DynObj.hh"
  #include "DynTmp.hh"
  using namespace NoPtr;
  
  struct Callee;
  struct Caller;
  typedef RRef<const Callee> CalleePtr;
  
  int created = 0;
  int deleted = 0;
  
  /*
      Class that registers itself to caller for notification events.
  */
  struct Callee: public RRefable
  {
      const int id; 
      
      Callee(): id(++created) 
      {
          std::cout << "Callee " << id << " being created" << std::endl;
      }
     ~Callee() 
      {
         deleted ++;
         std::cout << "Callee " << id << " being destroyed" << std::endl;
      }
      
      void registerSelf(Caller&) const;
      void notifyChange() const 
      { 
          std::cout << "Callee " << id << " heard notification" << std::endl;
      }
      
      private:
          Callee(const Callee& rhs);
  };
  
  /*
      Caller does stuff, and calls callees when something happens. 
  */
  struct Caller
  {
      std::list<CalleePtr> callees;
      
      void registerCallee(const CalleePtr& callee) 
      {
          assert(callee.isNotNull());
          callees.push_back(callee);
      }
      void notifyCallees() const 
      {
          for (std::list<CalleePtr>::const_iterator ii = callees.begin();
               ii != callees.end(); ++ii) 
          {
              if (ii->isNotNull()) (**ii).notifyChange();
              else std::cout << "Callee no longer exists, not notifying" 
                             << std::endl;
          }
      }
  };
  
  void 
  Callee::registerSelf(Caller& caller) 
  const 
  {
      // don't want to bother with a cloner
      caller.registerCallee(CalleePtr(*this));
  }
  
  int main()
  {
      // create caller:
      Caller caller;
      
      // create callees:
      std::cout << "Creation and registration:" << std::endl;
      typedef DynObj<Callee>::InValueContainerOpt2 CalleeOwned;
      std::list<CalleeOwned> callees;
      for (int i=0; i<5; ++i)
      {
          // Safely create and register one callee. Naturally, 
          // a Owned could be used instead of std::auto_ptr
          DynObj<Callee> callee(new Callee);
          callee().registerSelf(caller);
          
          // now add it to list without copy
          //cout << "Creating empty owner on list" << endl;
          callees.push_back(callee.giveAway());
          assert( isNull(callee) );
          assert( isNotNull( callees.back() ) );
          assert( callees.back().isNotNull() );
      }
      
      // discard the first and last Callees so caller really shows its stuff
      std::cout << "Destruction of first and last:" << std::endl;
      callees.pop_front();
      callees.pop_back();
      
      // create notification event
      std::cout << "Notification of callees:" << std::endl;
      caller.notifyCallees();
      
      std::cout << "Done program:" << std::endl;
  }
  
  /*
      Output (for g++ 3.2):
      Creation and registration:
      Callee 1 being created
      Callee 2 being created
      Callee 3 being created
      Callee 4 being created
      Callee 5 being created
      Destruction of first and last:
      Callee 1 being destroyed
      Callee 5 being destroyed
      Notification of callees:
      Callee no longer exists, not notifying
      Callee 2 heard notification
      Callee 3 heard notification
      Callee 4 heard notification
      Callee no longer exists, not notifying
      Done program:
      Callee 2 being destroyed
      Callee 3 being destroyed
      Callee 4 being destroyed
  */
  

---