config.h

Go to the documentation of this file.

#pragma once

#include "utils.h"
#include <list>

using std::list;

#define CFG_SEP '='
#define CFG_COMMENT "#"
#define DEFAULT_CFG "default.cfg"
#define SINGLE_VALUE -1

class Cfg;

enum itemType_e { IT_STR, IT_BOOL, IT_INT, IT_FLOAT, IT_INT_AR, IT_FLOAT_AR };

bool fillItemFromString(void* item, itemType_e type, string s, int index=SINGLE_VALUE);
string getItemAsString(void* item, itemType_e type, int index=SINGLE_VALUE);

class CfgItem
{
  public: 
    CfgItem(const char* name, itemType_e type, void* item, const char * defaultValue_);
  private:
    string name_;
    itemType_e type_;
    void * item_;
    bool set_;
    string defaultValue_;

    friend class Cfg;
};

typedef list<CfgItem > CfgItemList;
typedef CfgItemList::iterator CfgItemListIter;

class Values; 
class EvaluationValues; 
class StepKnowledgeValues; 

class Cfg
{
  public: 
    Cfg();

    void loadFromFile(string fn);

    void loadFromSection(string content);

    bool checkConfiguration();
    
    inline bool localPlayout() { return localPlayout_; }
    inline bool useBestEval() { return useBestEval_; }
    inline bool extensionsInEval() { return extensionsInEval_; }
    inline bool uct_tt() { return uct_tt_; }
    inline int vv() { return vv_; }
    inline bool ucbTuned() { return ucbTuned_; }
    inline bool dynamicExploration() { return dynamicExploration_; }
    inline bool childrenCache() { return childrenCache_; }
    inline bool knowledgeInTree() { return knowledgeInTree_;}
    inline bool uctRelativeUpdate() { return uctRelativeUpdate_;}
    inline bool historyHeuristic() { return historyHeuristic_;}
    inline float exploreRate() { return exploreRate_; }
    inline int playoutLen() { return playoutLen_; }
    inline int matureLevel() { return matureLevel_; }
    inline float tcMoveDefault() { return tcMoveDefault_; }
    inline bool exactPlayoutValue() { return exactPlayoutValue_; }
    inline bool knowledgeInPlayout() { return knowledgeInPlayout_;}
    inline float moveAdvisor() { return moveAdvisor_; }
    inline float activeTrapping() { return activeTrapping_; }
    inline bool playoutByMoves() { return playoutByMoves_; }
    inline uint knowledgeTournamentSize() { return knowledgeTournamentSize_; }
    inline int searchThreadsNum() { return searchThreadsNum_; }
    inline string evalCfg() { return evalCfg_; }

    inline EvaluationValues* evaluationValues() {return evaluationValues_;}
    inline StepKnowledgeValues* stepKnowledgeValues() {return stepKnowledgeValues_;}

  private:
    CfgItemList items_;

    bool localPlayout_;
    bool  useBestEval_;
    bool  extensionsInEval_;
    bool uct_tt_;
    int vv_;
    bool ucbTuned_;
    bool dynamicExploration_;
    bool childrenCache_;
    bool knowledgeInTree_;
    bool playoutByMoves_;
    bool uctRelativeUpdate_;
    bool historyHeuristic_;
    float exploreRate_;
    int playoutLen_;
    int matureLevel_;
    float tcMoveDefault_;
    bool exactPlayoutValue_;
    bool knowledgeInPlayout_;
    float  moveAdvisor_;
    float  activeTrapping_;
    uint knowledgeTournamentSize_;
    int searchThreadsNum_;
    string evalCfg_;

    EvaluationValues * evaluationValues_;
    StepKnowledgeValues * stepKnowledgeValues_;
};

enum optionType_e { OT_STRING, OT_BOOL_POS, OT_BOOL_NEG, OT_INT };
  
class Options;

class OptionFather
{
  protected: 
    string shortName_;
    string longName_;
    string description_;
    optionType_e  type_;
    bool parsed_;

    friend class Options;

  public:
    OptionFather(){};
    virtual ~OptionFather(){};
    OptionFather(string shortName, string longName, string description, optionType_e type):
      shortName_(shortName), longName_(longName), description_(description), type_(type) { parsed_ = false;};
    virtual void setValue(bool){};
    virtual void setValue(string){};
    virtual void setValue(int){};
    virtual void setValueParsed(bool){};
    virtual void setValueParsed(string){};
    virtual void setValueParsed(int){};
    bool parsed() { return parsed_;}
    virtual string toString(){ return "";};
    virtual string help(){ return "";};
};

template <typename T> class Option: public OptionFather
{
    T   value_;

  public:
    Option(){;};
    Option(string shortName, string longName, string description, optionType_e type, T defaultValue):
     OptionFather(shortName, longName, description, type), value_(defaultValue) {;};
    ~Option(){;};

    T getValue() { return value_;}
    void setValueParsed(T value) { if ( ! parsed_) { value_ = value; parsed_ = true;};}
    void setValue(T value) { value_ = value;}
     
    string toString() {
      stringstream ss;
      ss << "[" << shortName_ << ", " << longName_ << ", " << description_ << ", " << value_ << "]" << endl;
      return ss.str();
    } 

    string help() {
      stringstream ss;
      ss << "-" << shortName_ << ", --" << longName_ << ", " << description_ << endl;
      return ss.str();
    } 


};

typedef Option<int> OptionInt;
typedef Option<bool> OptionBool;
typedef Option<string> OptionString;

typedef list<OptionFather*> OptionList;

class Options
{
  private:
    OptionList  options_;
    OptionList  values_;

    OptionString fnAeiInit_;
    OptionString fnPosition_;
    OptionString fnRecord_;
    OptionString fnGameState_;
    OptionString fnCfg_;
    OptionBool benchmarkMode_; 
    OptionBool getMoveMode_; 
    OptionBool localMode_;
    OptionBool help_;

  public:
    Options();

    bool parse(const int, const char **);
    bool parseToken(string, string);
    bool parseValue(string);

    bool benchmarkMode() { return benchmarkMode_.getValue(); }
    bool localMode() { return localMode_.getValue(); }
    bool getMoveMode() { return getMoveMode_.getValue(); }
    bool help() { return help_.getValue(); }
    string fnAeiInit() { return fnAeiInit_.getValue(); }
    string fnPosition() { return fnPosition_.getValue(); }
    string fnRecord() { return fnRecord_.getValue(); }
    string fnGameState() { return fnGameState_.getValue(); }
    string fnCfg() { return fnCfg_.getValue(); }

    void printAll();
    string helpToString();
    
};

extern Cfg cfg;
extern Options options;

---