propertylist.h

Go to the documentation of this file.

/*-*-c++-*-*****************************************************************
                          propertylist.h  -  description
                             -------------------
    begin                : June 2003
    copyright            : (C) 2003 by Christian Stimming
    email                : stimming@tuhh.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef PROPERTYLIST_H
#define PROPERTYLIST_H

#include <string>
#include <iostream>
#include <map>
#include <utility>
//#include <list>
#include <vector>
#include <stdexcept>

#include <simthetic/misc.h>

// Needed for windows DLLs
#ifndef DLLIMPORT
#  if defined(__declspec) | defined(IS_WIN32)
#    if BUILDING_SIMTHETICBASE_DLL
#      define DLLIMPORT __declspec (dllexport)
#    else     /* Not BUILDING_SIMTHETICBASE_DLL */
#      define DLLIMPORT __declspec (dllimport)
#    endif    /* Not BUILDING_SIMTHETICBASE_DLL */
#  else
#    define DLLIMPORT
#  endif    /* __declspec */
#endif  /* DLLIMPORT */
#ifndef EXPIMP_TEMPLATE
#  if defined(__declspec) | defined(IS_WIN32)
#    if BUILDING_SIMTHETICBASE_DLL
#      define EXPIMP_TEMPLATE
#    else     /* Not BUILDING_SIMTHETICBASE_DLL */
#      define EXPIMP_TEMPLATE extern
#    endif    /* Not BUILDING_SIMTHETICBASE_DLL */
#  else
#    define EXPIMP_TEMPLATE
#  endif    /* __declspec */
#endif  /* DLLIMPORT */

#ifndef __GNUC__
// This macro enables a workaround which is necessary for Microsoft
// Visual C++. See below at Property::getValue().
# define MSVC_WORKAROUND(x) x
#else
# define MSVC_WORKAROUND(x)
#endif // __GNUC__

namespace simth
{


class DLLIMPORT Property
{
  public:
    enum p_type {
    bool_t,
    int_t,
    unsigned_t,
    double_t,
    complex_t,
    string_t,
    list_string_t,
    enum_t,
    sequencelength_t,
    vector_octal_int_t,
    vector_double_t,
    octal_int_t
    };

    typedef std::vector<std::pair<std::string,std::string> > StringPairList;
    typedef std::vector<std::string> list_string;
    typedef std::vector<int> vector_int;
    typedef std::vector<double> vector_double;

  private:
    std::string name_;
    p_type type_;
    std::string default_value_;
    bool empty_default_enabled_;
    std::string description_;
    union value_u {
      bool bool_v;
      int int_v;
      unsigned unsigned_v;
      double double_v;
      simth::Complex *complex_v;
      std::string *string_v;
      list_string *list_string_v;
      vector_int *vector_int_v;
      vector_double *vector_double_v;
    };
    value_u value_;
    bool isSet_;
    StringPairList possible_values;
    bool _obsolete;
    std::string _grouping;

    // Checks whether this is the given type.
    void check_type(p_type t) const;
  public:
    Property(const std::string& name, p_type type,
             const std::string& default_value = "",
             const std::string& description = "",
         const StringPairList& possible_values = StringPairList(),
         bool enable_empty_default = false,
         bool obsolete = false,
         const std::string& grouping = "");

    Property(const Property& p);

    Property();
    //Property& operator=(const Property& p);

    ~Property();

    const std::string& getName() const {return name_; };
    p_type getType() const {return type_;};
    const std::string& getDefault_value() const {return default_value_; };
    const std::string& getDescription() const {return description_; };

    bool hasDefault() const;
    bool isSet() const {return isSet_; };

    bool hasEmptyDefaultEnabled() const { return empty_default_enabled_; };

    const StringPairList& getPossibleValues() const
    { return possible_values; };

    bool obsolete() const { return _obsolete; };

    const std::string& grouping() const { return _grouping; };

    template<class T>
    void setValue(const T& value);

    template<class T>
    const T& getValue(MSVC_WORKAROUND(const T& dummyargument = 0)) const;

    void setValueStr(const std::string& v);

    std::string getValueStr() const;

    std::string toString() const;


    static const char *p_type_toString(p_type t);

    static p_type string_to_p_type(const std::string& t);

    static list_string supported_types();

    static list_string string_to_list(const std::string &s);

#ifndef __GNUC__
    // These are used by MSVC but not by GCC. See below.
    template<> void setValue(const bool& value);
    template<> void setValue(const int& value);
    template<> void setValue(const unsigned& value);
    template<> void setValue(const double& value);
    template<> void setValue(const Complex& value);
    template<> void setValue(const std::string& value);
    template<> void setValue(const list_string& value);
    template<> void setValue(const vector_int& value);
    template<> void setValue(const vector_double& value);

    template<> const bool& getValue(const bool& dummyargument) const;
    template<> const int& getValue(const int& dummyargument) const;
    template<> const unsigned& getValue(const unsigned& dummyargument) const;
    template<> const double& getValue(const double& dummyargument) const;
    template<> const Complex& getValue(const Complex& dummyargument) const;
    template<> const std::string& 
    getValue(const std::string& dummyargument) const;
    template<> const list_string& 
    getValue(const list_string& dummyargument) const;
    template<> const vector_int& 
    getValue(const vector_int& dummyargument) const;
    template<> const vector_double& 
    getValue(const vector_double& dummyargument) const;
#endif // ifndef __GNUC__
};

#ifdef __GNUC__
  // These are used by GCC only because MSVC doesn't accept these
  // specialisations outside of the class declaration, and GCC doesn't
  // accept the specialisations inside the class declaration.

/* Declarations of available specializations. These don't
 * necessarily have to appear here, but since we provide a default
 * template implementation below, we have to use these here. */
template<> void Property::setValue(const bool& value);
template<> void Property::setValue(const int& value);
template<> void Property::setValue(const unsigned& value);
template<> void Property::setValue(const double& value);
template<> void Property::setValue(const Complex& value);
template<> void Property::setValue(const std::string& value);
template<> void Property::setValue(const list_string& value);
template<> void Property::setValue(const vector_int& value);
template<> void Property::setValue(const vector_double& value);

template<> const bool& Property::getValue<bool>() const;
template<> const int& Property::getValue<int>() const;
template<> const unsigned& Property::getValue<unsigned>() const;
template<> const double& Property::getValue<double>() const;
template<> const Complex& Property::getValue<Complex>() const;
template<> const std::string& Property::getValue<std::string>() const;
template<> const Property::list_string& 
Property::getValue<Property::list_string>() const;
template<> const Property::vector_int&
Property::getValue<Property::vector_int>() const;
template<> const Property::vector_double&
Property::getValue<Property::vector_double>() const;

template<class T> const T& Property::getValue() const
{
  throw std::runtime_error("Property::getValue: "
                           "Your type is not (yet) implemented.");
}
#endif // __GNUC__

template<class T> void Property::setValue(const T& value)
{
  throw std::runtime_error("Property::setValue: "
                           "Your type is not (yet) implemented.");
}

class DLLIMPORT PropertyList
{
  private:
    typedef std::string key_type;

  public:
    typedef std::map<key_type, Property> map_type;

    typedef map_type::value_type value_type;
    typedef map_type::iterator iterator;
    typedef map_type::const_iterator const_iterator;
  private:
    map_type list;

  public:
    PropertyList();
    PropertyList(const PropertyList &);

    ~PropertyList();


    void addProperty(const std::string& name, const std::string& type,
                     const std::string& default_value = "",
                     const std::string& description = "",
             const Property::StringPairList& possible_values = 
             Property::StringPairList(),
             bool enable_empty_default = false);

    void addProperty(const Property& p);

    template<class propertyT>
    void setProperty(const std::string& name, const propertyT& value)
    { get(name).setValue(value); }


    template<class propertyT>
    const propertyT& getProperty(const std::string &name) const
    { return get(name).Property::getValue<propertyT>(); }
    // I have ZERO idea why getValue needs the extra qualifier
    // prefix. Really.

    Property& get(const std::string& name);
    const Property& get(const std::string& name) const;

    bool exists(const std::string& name) const;


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

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

    bool empty() const { return list.empty(); };
    size_t size() const { return list.size(); };

    bool remove(const std::string& name);


    void toStream(std::ostream& os) const;
};

std::ostream& operator<<(std::ostream& os, const PropertyList& pl);


#ifndef __GNUC__

EXPIMP_TEMPLATE template DLLIMPORT Property::list_string;
EXPIMP_TEMPLATE template DLLIMPORT Property::StringPairList;
EXPIMP_TEMPLATE template DLLIMPORT Property::vector_int;
EXPIMP_TEMPLATE template DLLIMPORT Property::vector_double;
EXPIMP_TEMPLATE template DLLIMPORT PropertyList::map_type;
#endif


Property::StringPairList to_stringpairs(const char**a);

} // namespace

#endif

---