Parameter.h

// Copyright (C) 2009 Anders Logg
//
// This file is part of DOLFIN.
//
// DOLFIN 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 3 of the License, or
// (at your option) any later version.
//
// DOLFIN 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 DOLFIN. If not, see <http://www.gnu.org/licenses/>.

#ifndef __PARAMETER_H
#define __PARAMETER_H

#include <array>
#include <set>
#include <sstream>
#include <string>
#include <boost/blank.hpp>
#include <boost/variant.hpp>

namespace dolfin
{


  class Parameter
  {
  public:

    template<typename T>
      Parameter(std::string key, T x) : _value(x), _access_count(0),
      _change_count(0), _is_set(true), _key(key),
      _description("missing description") { check_key(key); }

    Parameter(std::string key, const char* x);

    enum class Type { Bool, Int, Float, String };

    Parameter(std::string key, Type ptype);

    template<typename T>
      Parameter(std::string key, T min, T max) : _value(T(0)),
      _range(std::array<T, 2>({{min, max}})), _access_count(0), _change_count(0),
      _is_set(false), _key(key), _description("missing description")
    { check_key(key); }

  Parameter(std::string key, std::set<std::string> range) :  _value(std::string("")),
      _range(range), _access_count(0), _change_count(0), _is_set(false),
      _key(key), _description("missing description") { check_key(key); }

    Parameter(const Parameter&) = default;

    Parameter(Parameter&&) = default;

    virtual ~Parameter();

    Parameter& operator= (const Parameter &) = default;

    std::string key() const;

    std::string description() const;

    bool is_set() const;

    void reset();

    std::size_t access_count() const;

    std::size_t change_count() const;

    void set_range(int min_value, int max_value);

    void set_range(double min_value, double max_value);

    void set_range(std::set<std::string> range);

    void get_range(int& min_value, int& max_value) const;

    void get_range(double& min_value, double& max_value) const;

    void get_range(std::set<std::string>& range) const;

    const Parameter& operator= (int value);

    const Parameter& operator= (double value);

    const Parameter& operator= (std::string value);

    const Parameter& operator= (const char* value);

    const Parameter& operator= (bool value);

    boost::variant<boost::blank, bool, int, double, std::string> value() const;

    operator int() const;

    operator std::size_t() const;

    operator double() const;

    operator std::string() const;

    operator bool() const;

    std::string type_str() const;

    std::string value_str() const;

    std::string range_str() const;

    std::string str() const;

    static void check_key(std::string key);

  protected:

    // Value (0: blank, 1: bool, 2: int, 3: double, 4: std::string)
    boost::variant<boost::blank, bool, int, double, std::string> _value;

    // Ranges (0: blank, 1: int, 2: double, 3: std::string)
    boost::variant<boost::blank, std::array<int, 2>, std::array<double, 2>,
      std::set<std::string>> _range;

    // Access count
    mutable std::size_t _access_count;

    // Change count
    std::size_t _change_count;

    // Whether or not parameter has been set
    bool _is_set;

    // Parameter key
    std::string _key;

    // Parameter description
    std::string _description;

  };
}
#endif