ParameterMap.h

/*
Hyperspace Explorer - visualizing higher-dimensional geometry
Copyright (C) 2010  Lene Preuss <lene.preuss@gmail.com>

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.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#ifndef PARAMETERMAP_H
#define PARAMETERMAP_H

#include <iostream>
#include <map>
#include <sstream>

#include "FunctionParameterFactory.h"
#include "Log.h"


class ParameterMap : public std::map< std::string, FunctionParameter::parameter_ptr_type > {

  typedef std::map< std::string, FunctionParameter::parameter_ptr_type > map_type;

public:

    class NonexistentParameterAccessed: public std::invalid_argument {
    public:

      NonexistentParameterAccessed(const std::string &which, const ParameterMap &map):
        std::invalid_argument("Tried to access parameter \""+which+"\" in ParameterMap "+map.toString()) { }
    };

    ParameterMap(): ParameterMap::map_type() { }


    template<typename T> ParameterMap(const std::string &name, const T &value):
            ParameterMap::map_type() {
        insertByValue(name, value);
    }

    ~ParameterMap() { }


    template <typename T> void insertByValue(const std::string name, const T &value) {
      insert(
        std::make_pair(
          name,
          TheFunctionParameterFactory::Instance().createParameterWithValue(name, value)));
        }


    template <typename T> void insertByDefault(const std::string name, const T &defaultValue) {
      insert(
        std::make_pair(
          name,
          TheFunctionParameterFactory::Instance().createParameterWithDefault(name, defaultValue)));
        }

    FunctionParameter::parameter_ptr_type getParameter(const std::string &name);

    FunctionParameter::value_ptr_type getValue(const std::string &name);


    template <typename T> void set(const std::string &name, const T &value) {
      getParameter(name)->setValue(value.toString());
    }

    std::string toString() const;

  private:

    ParameterMap::iterator findOrThrow(const std::string &name);

};

template <> void ParameterMap::set(const std::string &name, const double &value);
template <> void ParameterMap::set(const std::string &name, const unsigned &value);
template <> void ParameterMap::set(const std::string &name, const int &value);
template <> void ParameterMap::set(const std::string &name, const std::string &value);

#endif