FIFO Factory pattern

• idiomFactoryFIFO1.cc:

  /*
      Test a less simple factory idiom.  Factory can create several 
      objects, which can be delivered on a first-in-first-out basis.
      The delivery takes place by assigning an DynObj<T> input argument 
      to the next available DynObj in the list of created objects.
      
      \author Oliver Schoenborn
      \since Apr 2003
  */
  
  
  #include <list>
  #include "Deriveds.hh"
  #include "DynObj.hh"
  #include "DynTmp.hh"
  using namespace NoPtr;
  
  /*
      Simple factory class that can store many created objects. The objects
      are delivered in the order they were created (FIFO, first-in-first-out).
  */
  class FactoryFIFO
  {
      typedef std::list<DynObj<Base>::InValueContainerOpt1> List;
      List objects;
      
      public:
          void create(const std::string& type) 
          {
              if (type=="derived1")
              {
                  objects.push_back(DynTmp<Base>(new Derived1));
              }
              else if (type=="derived2")
              {
                  objects.push_back(DynTmp<Base>(new Derived2));
              }
              else if (type=="derived3")
              {
                  objects.push_back(DynTmp<Base>(new Derived3));
              }
              else throw std::logic_error("Unknown type");
          }
          
          void getObj( DynObj<Base>& newOwner )
          { 
              std::cout << "FactoryFIFO: giving object from list" << std::endl;
              
              List::value_type& owner = objects.front();
              if ( owner.isNull()) 
                  throw std::logic_error("No object created yet");
              
              newOwner.acquire( owner );
              assert(objects.front().isNull());
              objects.erase(objects.begin());
          }
  };
  
  /*
      Get \a num objects form \a factoryFIFO.
  */
  void getObjects(FactoryFIFO& factoryFIFO, int num)
  {
      std::cout << "Getting FIFO objects" << std::endl;
      DynObj<Base> dynObj;
      for (int i=0; i<num; i++)
      {
          factoryFIFO.getObj( dynObj ); // ok too
          dynObj().callVirtual();
      }
  }
  
  int main()
  {
      try
      {
          std::cout << "Using FactoryFIFO" << std::endl;
          FactoryFIFO factoryFIFO;
          // create five objects
          factoryFIFO.create("derived1");
          factoryFIFO.create("derived2");
          factoryFIFO.create("derived3");
          factoryFIFO.create("derived2");
          factoryFIFO.create("derived1");
          
          // get only four objects
          getObjects(factoryFIFO, 4);
          std::cout << "Done FactoryFIFO use" << std::endl;
      }
      catch (const std::exception& e)
      {
          std::cout << e.what() << std::endl;
      }
  }
  
  /*
      Output (for g++ 3.2):
      
      Using FactoryFIFO
      Instantiating an 8Derived1# 1
      Instantiating an 8Derived2# 2
      Instantiating an 8Derived3# 3
      Instantiating an 8Derived2# 4
      Instantiating an 8Derived1# 5
      Getting FIFO objects
      FactoryFIFO: giving object from list
      8Derived1::callVirtual()# 1
      FactoryFIFO: giving object from list
      Destroying an 8Derived1# 1
      8Derived2::callVirtual()# 2
      FactoryFIFO: giving object from list
      Destroying an 8Derived2# 2
      8Derived3::callVirtual()# 3
      FactoryFIFO: giving object from list
      Destroying an 8Derived3# 3
      8Derived2::callVirtual()# 4
      Destroying an 8Derived2# 4
      Done FactoryFIFO use
      Destroying an 8Derived1# 5
  */
  

---