Common/Util/Params.h

Go to the documentation of this file.

//-------------------------------------------------------------------
//  Copyright (c) 2007 Celeritive Technologies, Inc.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//-------------------------------------------------------------------

#pragma once
#ifndef VOLUMILL_PARAMS_H
#define VOLUMILL_PARAMS_H

#include <map>
#include <boost/mpl/vector.hpp>
#include <boost/variant.hpp>
#include <Util/ParamIds.h>

namespace util
{
   namespace detail
   {
      typedef boost::mpl::vector<int, double, std::string> ParamTypes;
   }

   typedef boost::make_variant_over<detail::ParamTypes>::type ParamType;

   class Parameterized
   {
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int /*version*/)
      {
         ar & boost::serialization::make_nvp ("params", m_params);
      }
   public:
      virtual ~Parameterized() {}
      virtual void setParam (ParamId paramId, const ParamType& param)
      {
         m_params[paramId] = param;
      }
      template<class T>
      const T& getParam (ParamId paramId) const
      {
         ParamTable::const_iterator it = m_params.find (paramId);
         VALIDATE (it != m_params.end());
         return boost::get<T> (it->second);
      }
      template<class T>
      bool getParam (ParamId paramId, T* pT) const
      {
         ParamTable::const_iterator it = m_params.find (paramId);
         if (it != m_params.end())
         {
            *pT = boost::get<T> (it->second);
            return true;
         }
         return false;
      }
      virtual void deleteParam (ParamId paramId)
      {
         ParamTable::iterator it = m_params.find (paramId);
         if (it != m_params.end())
            m_params.erase (it);
      }
      void copyParamTable (const Parameterized& other)
      {
         for (std::map<ParamId, ParamType>::const_iterator it = other.m_params.begin();
            it != other.m_params.end(); ++it)
            m_params[it->first] = it->second;
      }
      size_t getNumParams () const
      {
         return m_params.size();
      }
   protected:
      typedef std::map<ParamId, ParamType> ParamTable;
      ParamTable m_params;
   };
}

#endif

---