Another FIFO Factory pattern

• idiomFactoryFIFO2.cc:

  /*
      Test another 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 transfering objectship. 
      
      \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).
      
      The delivery method (getObj) returns an objectship instead of accepting
      a non-const Owned, as does FactoryFIFO in testIdiomFactoryFIFO1.cc. 
      The owner that gives objectship must be alive when the other owner 
      takes objectship.  This requires a second list to be create, called
      'delivered'. 
  */
  class FactoryFIFO
  {
      std::list<DynObj<Base>::InValueContainerOpt2> objects;
      std::list<DynObj<Base>::InValueContainerOpt2> delivered;
      
      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");
          }
          
          DynTmp<Base> getObj() 
          { 
              DynObj<Base>::InValueContainerOpt2& owner = objects.front();
              if (owner.isNull()) 
                  throw std::logic_error("No object created");
              
              // Must move away from front so getObj can always pick 
              // up new object by calling front(). 
              delivered.splice(delivered.begin(), objects, objects.begin());
              return delivered.front().moveToTmp();
          }
  };
  
  /*
      Get \a num objects form \a factoryFIFO.
  */
  void getObjects(FactoryFIFO& factoryFIFO, int num)
  {
      std::cout << "Getting FIFO objects" << std::endl;
      DynObj<Base> mango;
      for (int i=0; i<num; i++)
      {
          mango = factoryFIFO.getObj();
          mango().callVirtual();
      }
  }
  
  int main()
  {
      try
      {
          std::cout << "Using FactoryFIFO again" << std::endl;
          FactoryFIFO factoryFIFO;
          // create five objects
          factoryFIFO.create("derived3");
          factoryFIFO.create("derived2");
          factoryFIFO.create("derived1");
          factoryFIFO.create("derived2");
          factoryFIFO.create("derived3");
          
          // 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 again
      Instantiating an 8Derived3# 1
      Instantiating an 8Derived2# 2
      Instantiating an 8Derived1# 3
      Instantiating an 8Derived2# 4
      Instantiating an 8Derived3# 5
      Getting FIFO objects
      8Derived3::callVirtual()# 1
      Destroying an 8Derived3# 1
      8Derived2::callVirtual()# 2
      Destroying an 8Derived2# 2
      8Derived1::callVirtual()# 3
      Destroying an 8Derived1# 3
      8Derived2::callVirtual()# 4
      Destroying an 8Derived2# 4
      Done FactoryFIFO use
      Destroying an 8Derived3# 5
  */
  

---