DtConfigurationCollection.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2007 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#ifndef DtConfigurationCollection_H_
#define DtConfigurationCollection_H_

#include <algorithm>
#include <vector>

#include <boost/serialization/split_member.hpp>
#include <boost/serialization/set.hpp>

namespace makVrv
{
   template <typename ConfigurationType>
   class DtConfigurationCollection
   {
   public:
      typedef std::vector<ConfigurationType*> Configurations;
      //typedef ConfigurationType ConfigurationType;
      typedef typename Configurations::iterator iterator;
      typedef typename Configurations::const_iterator const_iterator;

      DtConfigurationCollection() : myConfigurations()
      {
      }

      DtConfigurationCollection(const DtConfigurationCollection& copy)
      : myConfigurations()
      {
         addConfigurations(copy.myConfigurations);
      }

      DtConfigurationCollection& operator=(const DtConfigurationCollection& copy)
      {
         if(this == &copy) return *this;
         destroyAll();
         addConfigurations(copy.myConfigurations);
         return *this;
      }

      virtual ~DtConfigurationCollection()
      {
         destroyAll();
      }


      friend class boost::serialization::access;

      template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
      {
         ar & DT_SERIALIZE_MEMBER(myConfigurations);
      }
      

      virtual ConfigurationType& add(const ConfigurationType& orig)
      {
         typename Configurations::iterator curIter = myConfigurations.begin();
         typename Configurations::iterator endIter = myConfigurations.end();
         for(;curIter != endIter;++curIter)
         {
            if((*curIter)->name() == orig.name())
            {
               DtTHROW_NEW(DtInvalidInput,"A configuration with that name"
                  "already exists in the collection.");
            }
         }

         ConfigurationType* newConfig = new ConfigurationType(orig);
         myConfigurations.push_back( newConfig );
         return *newConfig;
      }

      virtual void destroyConfiguration(ConfigurationType* config)
      {
         typename Configurations::iterator iter = std::find(myConfigurations.begin(), myConfigurations.end(), config);
         if(iter == myConfigurations.end())
         {
            return;
         }

         myConfigurations.erase(iter);
         delete config;         
      }

      size_t size() const { return myConfigurations.size(); }

      iterator begin() { return myConfigurations.begin(); }
      const_iterator begin() const  { return myConfigurations.begin(); }

      iterator end() { return myConfigurations.end(); }
      const_iterator end() const  { return myConfigurations.end(); }


      const Configurations& configurations() const
      {
         return myConfigurations;
      }

      void addConfigurations(const Configurations& configs)
      {
         typename Configurations::const_iterator curIter = configs.begin();
         typename Configurations::const_iterator endIter = configs.end();
         for(;curIter != endIter;++curIter)
         {
            add(**curIter);
         }
      }

      void destroyAll()
      {
         typename Configurations::iterator curIter = myConfigurations.begin();
         typename Configurations::iterator endIter = myConfigurations.end();
         for(;curIter != endIter;++curIter)
         {
            delete *curIter;
         }
         myConfigurations.clear();
      }

      virtual ConfigurationType* findConfiguration(const std::string& name)
      {
         typename Configurations::iterator curIter = myConfigurations.begin();
         typename Configurations::iterator endIter = myConfigurations.end();
         for(;curIter != endIter;++curIter)
         {
            if((*curIter)->name() == name)
            {
               return (*curIter);
            }
         }
         return 0;
      }

      virtual const ConfigurationType* findConfiguration(const std::string& name) const
      {
         typename Configurations::const_iterator curIter = myConfigurations.begin();
         typename Configurations::const_iterator endIter = myConfigurations.end();
         for(;curIter != endIter;++curIter)
         {
            if((*curIter)->name() == name)
            {
               return (*curIter);
            }
         }
         return 0;
      }

   protected:

      Configurations myConfigurations;

   };
}

#endif