DeSR Dependency Parser

ixe/conf/conf.h

/*
**  IXE C++ Library
**  ixe/conf/conf.h
**  ----------------------------------------------------------------------
**  Copyright (c) 2000  Ideare SpA.
**  Copyright (c) 2000  Giuseppe Attardi (attardi@di.unipi.it).
**  ----------------------------------------------------------------------
**
**  This file is part of DeSR.
**
**  DeSR is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  DeSR 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, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef IXE_conf_H
#define IXE_conf_H

// Settings
#include "platform.h"

// standard
#include <iostream>
#include <map>
#include <string>

// local
#include "text/less.h"

namespace IXE {

class Configuration
{

public:

  // Note that the declaration of std::map has a default "Compare"
  // template parameter of "less<key_type>" and, since we've included
  // less.h above that defines "less<char const*>", C-style string
  // comparisons work properly.
  //
  class Item;
  typedef std::map<char const*, Item*> Map;

  static void           load(char const* file_name);

  static void           load(std::istream& is, Map* parameters = 0,
                             char const* = "</desr>");

  static Map&           variables();

  static void           reset();

  static std::ostream&  error(std::ostream& o = std::cerr) {
    return msg(o, "error");
  }
  static std::ostream&  warning(std::ostream& o = std::cerr) {
    return msg(o, "warning");
  }

private:
  static int            current_config_file_line_no;

  static void           insert(Item* var);

  static void           parseLine(char const*& line, int& line_no,
                                  Map* vars = 0);

  static std::ostream&  msg(std::ostream&, char const* label);

public:

  friend class Item;
  class Item
  {
  public:
    char const* name() const { return name_; }

    virtual void serialize(std::ostream& os) {}

  protected:
    Item(char const* name) : name_(name) {
      Configuration::insert(this);
    }

    virtual             ~Item() { };

    virtual void        parseValue(char const*& line) = 0;
    //          Derived classes must define this to parse a line and
    //          set their value.

    virtual void        reset() = 0;
    //          Reset value to default.  Derived classes must define
    //          this.

    // so that Configuration::parseLine() can call parseValue()
    friend class Configuration;

  private:

    char const* const   name_;
  };
};

template <class T>
class Var : public Configuration::Item
{
public:
  typedef T     value_type;

  Var(char const* name) : Item(name) { }
                                             
  inline operator       T() const { return this->value; }
  inline operator       T*() const { return &this->value; }

  T& operator *() { return this->value; }
  T* operator ->() { return &this->value; }
  /*
    Var<T>&     operator =(std::string const& s) {
    parseValue(s.c_str());
    return *this;
    }

    Var<T>&     operator =(char const* s) {
    parseValue(s);
    return *this;
    }

    Var<T>& operator =(T new_value) {
    this->value = new_value;
    return *this;
    }
  */

  void serialize(std::ostream& os) {
    os << name() << '\t' << value << std::endl;
  }

  T             value;          

protected:
  Var(char const* name, T value) :
    Item(name), value(value) { }

};

template <class T> class VarDefault : public Var<T>
{
  VarDefault() { }

public:

  T             Default() { return default_value; }

protected:
  VarDefault(char const *name, T default_value) :
    Var<T>(name, default_value), default_value(default_value) { }

  virtual void  reset() { Var<T>::value = default_value; }

private:
  T             default_value;
};

// So that we can specialize it later
template <class T> class conf : public Configuration::Item { };

char const*             next_token_line(char const*& start, const char* sep,
                                        char esc = '\\');
} // namespace IXE

#endif  /* IXE_conf_H */

 

Copyright © 2005-2007 G. Attardi. Generated on 13 Aug 2009 by doxygen 1.5.7.1.