param.h

Go to the documentation of this file.

// Copyright (C) 2006 Ivo Nowak and Stefan Vigerske
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Author: Stefan Vigerske

#ifndef PARAM_H
#define PARAM_H

#include "standard.h"

class ParamTree {
  public:
    ParamTree *left, *right;

    const char *name;

    const char *value;

    ParamTree(const char* name_, const char* value_=(char*)NULL)
    : left(NULL), right(NULL), name(name_), value(value_)
    { if (! name_) {
        out_err << "Can't handle NULL-pointer as argument for ParamTree::ParamTree(char*, char*=0)." << endl;
        exit(-1);
      }
    }

    ParamTree(ParamTree &PT)
    : name(strdup(PT.name)), value(PT.value ? strdup(PT.value) : NULL),
      left(PT.left ? new ParamTree(*PT.left) : NULL),
      right(PT.right ? new ParamTree(*PT.right) : NULL)
    { }

                ~ParamTree();

    void add(const char* name_, const char* value_=(const char*)NULL);

    const char* get(const char* name_);

    void dump(ostream& out);

};

class Param {

  friend ostream& operator<<(ostream &out, Param& a) {
    if (a.head) a.head->dump(out);
    else out << "Empty parameter-tree";
    return out;
  }

private:
  int filenr;

  ifstream *file;

  vector<char*> paramfiles;

  ParamTree *head;

public:
  char *basedir;

  Param(vector<char*> &paramfiles_, const char* basedir_="resource/")
  : paramfiles(paramfiles_.size()), filenr(-1), head(NULL), basedir(basedir_ ? strdup(basedir_) : new char(0))
  { for (int i=0; i<paramfiles_.size(); i++)
      paramfiles[i]=(paramfiles_[i] ? strdup(paramfiles_[i]) : NULL);
  }

  Param(const char* paramfile_, const char* basedir_="resource/")
  : paramfiles(paramfile_ ? 1 : 0), filenr(-1), head(NULL), basedir(basedir_ ? strdup(basedir_) : new char(0))
  {
    if (paramfile_) paramfiles[0]=strdup(paramfile_);
  }

  Param() : filenr(-1), head(NULL), basedir("resource/") { }

  Param(Param& P) {
    *this=P;
  }

  ~Param();
  
  void add_file(char* filename) {
    if (filename) paramfiles.push_back(strdup(filename));
  }

  int read();

        Pointer<char> get(const char *name, const char* def=(const char*)NULL) const {
    const char* parvalue=(head ? head->get(name) : NULL);
    return (parvalue ? strdup(parvalue) : (def ? strdup(def) : NULL));
  }

  double get_d(const char* name_, double def=0) const {
    Pointer<char> parvalue=get(name_);
    double val=(parvalue ? (double)atof(parvalue) : def);

//    if (parvalue) free(parvalue);
    return val;
  };

  int get_i(const char* name_, int def=0) const {
    Pointer<char> parvalue=get(name_);
    int val=(parvalue ? atoi(parvalue) : def);

//    if (parvalue) free(parvalue);
    return val;
  }

  void add(const char* name_, const char* value_) {
    if (!name_) return;
    if (head) head->add(strdup(name_), value_ ? strdup(value_) : NULL);
    else head=new ParamTree(strdup(name_), value_ ? strdup(value_) : NULL);
  }

  Param& operator = (const Param &p)
  {
    if (&p != this) {  // Check against self assignment
      basedir = (p.basedir ? strdup(p.basedir) : new char(0));

      for (int i=0; i<p.paramfiles.size(); i++)
        paramfiles.push_back(p.paramfiles[i] ? strdup(p.paramfiles[i]) : NULL);

      filenr=p.filenr;

      head=(p.head ? new ParamTree(*p.head) : NULL);
    }
    return *this;
  }
};

#endif // PARAM_H

---