parameter.h

Go to the documentation of this file.

//    sampalib.org ESL library and tools
//    Copyright (C) 2007  Thierry Grellier
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License version 2 as
//    published by the Free Software Foundation.
//
//    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.
//
//    contact: www.sampalib.org

#ifndef SAMPA_PARAMETER_H
#define SAMPA_PARAMETER_H

#include <string>
#include "sampa/core/persistence.h"
#include "sampa/core/time.h"

namespace Sampa {

template <class>    class ParameterInitializer;
template <typename> class EnumeratedParameterInitializer;

class ParameterManager;
class LuaInterpreter;

void parameter_initialize(LuaInterpreter* interpreter, const std::string& init_parm_table);

class ParameterGroupName {
public:
  ParameterGroupName(const char*);
  ParameterGroupName(const std::string&);
  ParameterGroupName(const ParameterGroupName&);
  ~ParameterGroupName();
  const std::string& get_name() const { return m_name; }
  bool is_pushed() const { return m_pushed; }
private:
  std::string         m_name;
  ParameterGroupName* m_next;
  bool                m_pushed;
  // disabled
  ParameterGroupName();
  ParameterGroupName& operator=(const ParameterGroupName&);
  friend class ParameterManager;
};

class SAMPA_PERSISTENT_CLASS(BoolParameter) {
public:
  BoolParameter(const char* name);
  BoolParameter(const char* name, bool default_value);
  inline operator bool() const { return m_value; }
  inline bool get_value() const { return m_value; } 
  void update(const char*);
private:
  bool m_value;
  friend class ParameterInitializer<BoolParameter>;
  SAMPA_PERSISTENT(BoolParameter);
};

class SAMPA_PERSISTENT_CLASS(IntParameter) {
public:
  IntParameter(const char* name);
  IntParameter(const char* name, int default_value);
  inline operator int() const { return m_value; }
  inline int get_value() const { return m_value; } 
  void update(const char*);
private:
  int m_value;
  friend class ParameterInitializer<IntParameter>;
  SAMPA_PERSISTENT(IntParameter);
};

class SAMPA_PERSISTENT_CLASS(HexParameter) {
public:
  HexParameter(const char* name);
  HexParameter(const char* name, unsigned long long  default_value);
  inline operator unsigned long long () const { return m_value; }
  inline unsigned long long  get_value() const { return m_value; } 
  void update(const char*);
private:
  unsigned long long m_value;
  friend class ParameterInitializer<HexParameter>;
  SAMPA_PERSISTENT(HexParameter);
};

class SAMPA_PERSISTENT_CLASS(StringParameter) {
public:
  StringParameter(const char* name);
  StringParameter(const char* name, const std::string& default_value);
  inline operator const char* const () const { return m_value.c_str(); }
  inline const char* get_value() const { return m_value.c_str(); } 
  void update(const char*);
private:
  std::string m_value;
  friend class ParameterInitializer<StringParameter>;
public:
  SAMPA_PERSISTENT(StringParameter);
};

class SAMPA_PERSISTENT_CLASS(DoubleParameter) {
public:
  DoubleParameter(const char* name);
  DoubleParameter(const char* name, double default_value);
  inline operator double() const { return m_value; }
  inline double get_value() const { return m_value; } 
  void update(const char*);
private:
  double m_value;
  friend class ParameterInitializer<DoubleParameter>;
public:
  SAMPA_PERSISTENT(DoubleParameter);
};

class SAMPA_PERSISTENT_CLASS(TimeParameter) {
public:
  TimeParameter(const char* name);
  TimeParameter(const char* name, const Time& default_value);
  inline operator const Time&() const { return m_value; }
  inline const Time& get_value() const { return m_value; } 
  void update(const char*);
private:
  Time m_value;
  friend class ParameterInitializer<TimeParameter>;
public:
  SAMPA_PERSISTENT(TimeParameter);
};

class SAMPA_PERSISTENT_CLASS(SizeParameter) {
public:
  SizeParameter(const char* name);
  inline operator const int&() const { return m_value; }
  inline const int& get_value() const { return m_value; } 
  void update(const char*);
private:
  int m_value;
  friend class ParameterInitializer<SizeParameter>;
public:
  SAMPA_PERSISTENT(SizeParameter);
};

template <typename Enumerated>
class SAMPA_PERSISTENT_CLASS(EnumeratedParameter) {
public:
  EnumeratedParameter(const char* name);
  EnumeratedParameter(const char* name, Enumerated default_value);
  inline operator Enumerated() const { return m_value; }
  inline const Enumerated& get_value() const { return m_value; } 
  void update(const char*);
private:
  Enumerated m_value;
  friend class EnumeratedParameterInitializer<Enumerated>;
  SAMPA_PERSISTENT(EnumeratedParameter);
};

} // namespace Sampa

#endif

---