---

HalftonerFactory.cxx

Go to the documentation of this file.

/*
 * @(#)src/HalftonerFactory.cxx  1.0  2002-08-26 10:53
 *
 * Copyright (C)  2002  Daniel Léonard
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include <utility>
#include "HalftonerFactory.h"
#include "Instanciator.h"

#include "FloydSteinbergInstanciator.h"
#include "JarvisJudiceNinkeInstanciator.h"
#include "StuckiInstanciator.h"
#include "VG91Instanciator.h"
#include "VG95Instanciator.h"
#include "VGexpInstanciator.h"

namespace halftoner
{

//------------------------------------------
// Class HalftonerFactory::Repository
//------------------------------------------

//---------------------------
// Constructor
//---------------------------

   HalftonerFactory::Repository::Repository() throw()
   {
      Instanciator* instanciator = 0;
      const char* name = 0;
      try
      {
   //std::cout << "got instanciator, adding it" << std::endl;
   //      this->add(HalftonerFactory::FLOYD_STEINBERG, instanciator);

         std::map<const char*, const Instanciator*>& collection = this->depot;

         name = HalftonerFactory::FLOYD_STEINBERG;
         instanciator = new FloydSteinbergInstanciator();
         /*std::pair<std::map<const char*, const Instanciator*>::iterator, bool> result = */collection.insert(std::make_pair(name, instanciator));

         name = HalftonerFactory::JARVIS_JUDICE_NINKE;
         instanciator = new JarvisJudiceNinkeInstanciator();
         /*std::pair<std::map<const char*, const Instanciator*>::iterator, bool> result = */collection.insert(std::make_pair(name, instanciator));

         name = HalftonerFactory::STUCKI;
         instanciator = new StuckiInstanciator();
         /*std::pair<std::map<const char*, const Instanciator*>::iterator, bool> result = */collection.insert(std::make_pair(name, instanciator));

         name = HalftonerFactory::VG91;
         instanciator = new VG91Instanciator();
         /*std::pair<std::map<const char*, const Instanciator*>::iterator, bool> result = */collection.insert(std::make_pair(name, instanciator));

         name = HalftonerFactory::VG95;
         instanciator = new VG95Instanciator();
         /*std::pair<std::map<const char*, const Instanciator*>::iterator, bool> result = */collection.insert(std::make_pair(name, instanciator));

         name = HalftonerFactory::VGEXP;
         instanciator = new VGexpInstanciator();
         /*std::pair<std::map<const char*, const Instanciator*>::iterator, bool> result = */collection.insert(std::make_pair(name, instanciator));
   /*
         bool success = result.second;

         if (false == success)
         {
            std::string message("The key : ");
            message += name;
            message += " is already in the map";
            throw std::invalid_argument(message);
         }
   */


      }
      catch (std::invalid_argument& ia)
      {
   // TODO : notify the user of the error
      }
   }


//---------------------------
// Destructor
//---------------------------

   HalftonerFactory::Repository::~Repository() throw()
   {
      std::map<const char*, const Instanciator*>& collection = this->getMap();

      std::map<const char*, const Instanciator*>::iterator iter = collection.begin();
      std::map<const char*, const Instanciator*>::iterator end = collection.end();

      while (iter != end)
      {
         const std::pair<const char*, const Instanciator*>& item = *iter;
         const Instanciator* instanciator = item.second;
         delete instanciator;
         iter++;
      }

      collection.clear();
   }


//---------------------------
// Accessor
//---------------------------

   std::map<const char*, const Instanciator*>& HalftonerFactory::Repository::getMap() throw()
   {
      return this->depot;
   }


//---------------------------
// Instance method
//---------------------------

   void HalftonerFactory::Repository::add(const char* name, const Instanciator* instanciator) throw (std::invalid_argument)
   {
   // make the object to be inserted
      std::pair<const char*, const Instanciator*> value = std::make_pair(name, instanciator);

   // insert the pair
      std::map<const char*, const Instanciator*>& collection = this->getMap();
      std::pair<std::map<const char*, const Instanciator*>::iterator, bool> result = collection.insert(value);

   // notify if the user if the object had not an unique key
      bool success = result.second;
      if (false == success)
      {
         std::string message("The key : ");
         message += name;
         message += " is already in the map";
         throw std::invalid_argument(message);
      }
   }

   const Instanciator* HalftonerFactory::Repository::get(const char* name) throw ()
   {
   // get the iterator pointing to the pair holding the instanciator
      std::map<const char*, const Instanciator*>& collection = this->getMap();
      std::map<const char*, const Instanciator*>::iterator iter = collection.find(name);

   // verify if it maps
      const Instanciator* instanciator = 0;
      if (collection.end() != iter)
      {
         instanciator = (*iter).second;
      }

      return instanciator;
   }


//------------------------------------------
// Class HalftonerFactory
//------------------------------------------

//---------------------------
// Class variables
//---------------------------

   HalftonerFactory::Repository HalftonerFactory::repository;

   const char* HalftonerFactory::FLOYD_STEINBERG = "FloydSteinberg";
   const char* HalftonerFactory::JARVIS_JUDICE_NINKE = "JarvisJudiceNinke";
   const char* HalftonerFactory::STUCKI = "Stucki";
   const char* HalftonerFactory::VG91 = "VG91";
   const char* HalftonerFactory::VG95 = "VG95";
   const char* HalftonerFactory::VGEXP = "VGexp";


//---------------------------
// Destructor
//---------------------------

   HalftonerFactory::~HalftonerFactory() throw()
   {
   // nothing
   }


//---------------------------
// Class methods
//---------------------------

   HalftonerFactory::Repository& HalftonerFactory::getRepository() throw()
   {
      return HalftonerFactory::repository;
   }

   void HalftonerFactory::addHalftoner(const char* key, const Instanciator* instanciator) throw (std::invalid_argument)
   {
      if (0 == key)
      {
         std::string message("key parameter is 0");
         throw std::invalid_argument(message);
      }
      if (0 == instanciator)
      {
         std::string message("instanciator parameter is 0");
         throw std::invalid_argument(message);
      }

   // add to the repository
      HalftonerFactory::Repository& repository = HalftonerFactory::getRepository();
      repository.add(key, instanciator);
   }

   Halftoner* HalftonerFactory::getInstance(const char* key) throw (std::invalid_argument)
   {
      if (0 == key)
      {
         std::string message("key parameter is 0");
         throw std::invalid_argument(message);
      }

   // get an instanciator
      HalftonerFactory::Repository& repository = HalftonerFactory::getRepository();
      const Instanciator* instanciator = repository.get(key);

   // make sure it exists
      if (0 == instanciator)
      {
         std::string message("Could not create halftoner : ");
         message += key;
         throw std::invalid_argument(message);
      }

   // make the halftoner object
      Halftoner* halftoner = instanciator->operator()();
      return halftoner;
   }

}

---