Tanl Linguistic Pipeline

search/ixe/conf/conf.h

/*
**      IXE
**      conf/conf.h
** ----------------------------------------------------------------------
**      Copyright (c) 2000  Ideare SpA. All rights reserved.
**      Copyright (c) 2000  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of IXE.
**
**  IXE 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.
**
**  IXE 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:
  //    Load configuration from file.
  static void           load(char const* file_name);

  // 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 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);

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

public:

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

  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;
        }
  */
        T               value;
        //              the configured value.

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

};

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

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 { };

} // namespace IXE

#endif  /* IXE_conf_H */

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.