/home/rex/ebltrunk/tools/libeblearntools/include/configuration.h

/***************************************************************************
 *   Copyright (C) 2009 by Pierre Sermanet   *
 *   pierre.sermanet@gmail.com   *
 *   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Redistribution under a license not approved by the Open Source
 *       Initiative (http://www.opensource.org) must display the
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ThE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***************************************************************************/

#ifndef CONFIGURATION_H_
#define CONFIGURATION_H_

#include <map>
#include <vector>
#include "defines.h"
#include "utils.h"
#include <list>

using namespace std;

namespace ebl {


  typedef map<string, string, less<string> > string_map_t;
  typedef map<string, vector<string>, less<string> > string_list_map_t;

  class textlist : public list< pair<string,string> > {
  public:
    textlist();

    textlist(const textlist &txt);

    virtual ~textlist();

    void update(const string &varname, const string &value);

    void print(ostream &out);
  };

  // utility functions

  string timestamp();

  class EXPORT configuration {
  public:
    configuration();
    configuration(const configuration &other);
    configuration(const char *filename, bool replquotes = false,
                  bool silent = false, bool resolve = true);
    configuration(const string &filename, bool replquotes = false,
                  bool silent = false, bool resolve = true);
    configuration(string_map_t &smap, textlist &txt, string &name,
                  string &output_dir);
    virtual ~configuration();

    // input/output ////////////////////////////////////////////////////////////

    bool read(const char *fname, bool resolve = true, bool replquotes = true,
              bool silent = false, const char *outdir = NULL);
    bool write(const char *fname);
    void resolve(bool replquotes = false);
    void resolve_bq();

    // accessors ///////////////////////////////////////////////////////////////

    const string &get_name();
    void set_name(const string &name);
    const string &get_output_dir();
    void set_output_dir(const string &d);

    template <typename T>
      void get(T &v, const char *varname);

    template <typename T>
      void get(T &v, const std::string &varname);

    void get(intg &v, const char *varname);
    void get(uint &v, const char *varname);
    void get(double &v, const char *varname);
    void get(float &v, const char *varname);
    void get(string &v, const char *varname);
    void get(bool &v, const char *varname);

    const string &get_string(const char *varname);

    const string &get_string(const string &varname);

    const char *get_cstring(const char *varname);

    double get_double(const char *varname);

    uint try_get_uint(const char *varname, uint default_val);
    int try_get_int(const char *varname, int default_val);
    intg try_get_intg(const char *varname, intg default_val);
    float try_get_float(const char *varname, float default_val);
    double try_get_double(const char *varname, double default_val);
    string try_get_string(const char *varname, const char *default_val = "");

    float get_float(const char *varname);

    uint get_uint(const char *varname);

    int get_int(const char *varname);

    intg get_intg(const char *varname);

    bool get_bool(const char *varname);

    char get_char(const char *varname);

    bool exists_bool(const char *varname);

    bool exists_true(const char *varname);

    bool exists_true(const string &varname);

    bool exists_false(const char *varname);

    void exists_throw(const char *varname);

    void set(const char *varname, const char *value);

    const char* get_cstr(const char *varname, bool silent = false);
    vector<string> get_all_strings(const string &s);

    bool exists(const char *varname);
    bool exists(const std::string &varname);

    virtual void pretty();
    virtual void pretty_match(const string &s);

  protected:

    void resolve_variables(string_map_t &m, bool replquotes = false);

    string resolve0(string_map_t &m, const string &variable,
                    const string &v, bool firstonly = false);

    string resolve_backquotes(string_map_t &m,
                             const string &variable, const string &v,
                             bool firstonly = false);

    string resolve_string(string_map_t &m, const string &variable,
                          const string &v, bool firstonly = false);

    // open file fname and put variables assignments in smap.
    // e.g. " i = 42 # comment " will yield a entry in smap
    // with "i" as first value and "42" as second value.
    bool extract_variables(const char *fname, string_map_t &smap, textlist &txt,
                           string_map_t *meta_smap = NULL, bool bresolve = true,
                           bool replquotes = false, bool silent = false);

  protected:
    string_map_t        smap;   
    string_map_t        tmp_smap; 
    string              name;   
    string              output_dir;     
    textlist            otxt;   
    bool                silent;
  };

  class EXPORT meta_configuration : public configuration {
  private:
    string_list_map_t   lmap;
    vector<size_t>      conf_indices;
    int                 conf_combinations;
    vector<configuration> confs;

  public:
    meta_configuration();
    virtual ~meta_configuration();

    bool read(const char *fname, bool bresolve = true,
              const string *tstamp = NULL,
              bool replace_quotes = false,
              const char *resume_name = NULL,
              bool silent = false);

    // accessors

    vector<configuration>& configurations();

    virtual void pretty();

    virtual void pretty_combinations();
  };

} // end namespace ebl

#include "configuration.hpp"

#endif /* CONFIGURATION_H_ */