Parameter_Map.h

#ifndef QNANO_NEW_PARAMETER_LIST_DEFINED_H
#define QNANO_NEW_PARAMETER_LIST_DEFINED_H

#include "tools/Reader.h"
#include "tools/Debug_Logger.h"
#include "tools/Vec3d.h"
#include <map>
#include <algorithm>

typedef std::vector<std::vector<std::string> > Parameter_Values;

class Parameter_Map{
//private:
public:
  int *p_args; char ***p_argv;
  std::map<std::string, Parameter_Values > map;


  std::vector<std::string> requested;
  bool use_check_requested_on_destruction;


  Debug_Logger logger;

  typedef std::map<std::string, std::vector<std::vector<std::string> > >::iterator map_iter;
  typedef std::map<std::string, std::vector<std::vector<std::string> > >::const_iterator map_const_iter;
   std::vector<std::vector<std::string> > empty_stringvecvec;

public:

  void add(const std::string &key, const std::vector<std::string> & stringvec);
  void add(const std::string &key, const std::string &str);

  void set_requested(const std::string &key);

  bool is_specified(const std::string &key, size_t row=0, size_t col=0);
  bool is_double(const std::string &key);
  bool is_bool(const std::string &key);
  bool is_Vec3d(const std::string &key, size_t row=0, size_t col=0);
  bool is_VecXd(const std::string &key, size_t X, size_t row=0, size_t col=0);
  void complain_if_not_specified(const std::string &key, std::ostream &ofs=std::cerr);
  void quit_if_not_specified(const std::string &key, size_t row=0, size_t col=0);
  void override_parameter(const std::string &key, const std::vector<std::string> & stringvec);
  void override_parameter(const std::string &key, const std::string &value){
    override_parameter(key,std::vector<std::string>(1,value));
  }
  void override_parameter(const std::string &key, double value){
    override_parameter(key,Reader::toString(value));
  }

  const Parameter_Values  & get(const std::string &key);

  size_t get_rows(const std::string &key);
  size_t get_cols(const std::string &key, size_t row);
  
  //condense string_vec_vec to string_vec:
  std::vector<std::string> get_all_strings(const std::string &key);

  std::string get_as_string(const std::string &key, const std::string default_="", size_t row=0, size_t col=0);
/*  inline std::string get_as_string(const char* key, const char* default_="", size_t row=0, size_t col=0){
    return get_as_string(std::string(key),std::string(default_),row,col);
  }*/
  std::string get_as_string_check(const std::string &key, const std::string default_="", size_t row=0, size_t col=0){
    quit_if_not_specified(key,row,col);
    return get_as_string(key,default_, row, col);
  }

  double get_as_double(const std::string &key, double default_=0., size_t row=0, size_t col=0);
  double get_as_double_check(const std::string &key, double default_=0., size_t row=0, size_t col=0){ 
    quit_if_not_specified(key, row, col);
    return get_as_double(key,default_,row,col);
  }
  size_t get_as_sizet(const std::string &key, size_t default_=0., size_t row=0, size_t col=0){
    int i=get_as_double(key,default_,row,col);
    if(i<0){ std::cerr<<"Parameter_Map::get_as_sizet: value less than zero!"<<std::endl; exit(1);}
    return i;
  }
  double get_as_sizet_check(const std::string &key, size_t default_=0., size_t row=0, size_t col=0){ 
    quit_if_not_specified(key, row, col);
    return get_as_sizet(key,default_,row,col);
  }

  bool get_as_bool(const std::string &key, bool default_=false, size_t row=0, size_t col=0);



  std::vector<double> get_as_VecXd(const std::string &key, size_t X, std::vector<double> default_=std::vector<double>(), size_t row=0, size_t col=0);

  Vec3d get_as_Vec3d(const std::string &key, Vec3d default_=Vec3d(), size_t row=0, size_t col=0){
    std::vector<double> default_vec(3); 
    default_vec[0]=default_[0];
    default_vec[1]=default_[1];
    default_vec[2]=default_[2];
    std::vector<double> v=get_as_VecXd(key, 3, default_vec, row, col);
    return Vec3d(v[0],v[1],v[2]);
  }
  inline Vec3d get_as_Vec3d(const char* key, Vec3d default_=Vec3d(), size_t row=0, size_t col=0){
    return get_as_Vec3d(std::string(key),default_,row,col);
  }
  inline Vec3d get_as_Vec3d_check(const std::string &key, Vec3d default_=Vec3d(), size_t row=0, size_t col=0){
    quit_if_not_specified(key);
    return get_as_Vec3d(key, default_, row, col);
  }


  void add_from_file(const std::string &filename);
  void add_from_command_line(int args, char** argv);
  void add_from_command_line_or_driver(int args, char** argv);


  void print(std::ostream &ofs)const;
  void print(const std::string filename)const;
  void print(const char* filename)const;

  void check_requested()const;

  void setup_logger(){
    logger.setup(get_as_string("debug_log"));
  }
  

  void copy(const Parameter_Map &other){
    map=other.map;
    use_check_requested_on_destruction=false;
    logger=other.logger;
  }
  Parameter_Map &operator=(const Parameter_Map &other){
    copy(other);
    return *this;
  }
  Parameter_Map(const Parameter_Map &other){
    copy(other);
  }
  Parameter_Map(const std::string &filename, bool use_check_requested=false){
    use_check_requested_on_destruction=use_check_requested;
    add_from_file(filename);
    setup_logger();
  }
  Parameter_Map(const char* filename, bool use_check_requested=false){
    use_check_requested_on_destruction=use_check_requested;
    add_from_file(std::string(filename));
    setup_logger();
  }
  Parameter_Map(int &args, char** &argv, bool use_check_requested=false){
    p_args=&args; p_argv=&argv;
    use_check_requested_on_destruction=use_check_requested;
    add_from_command_line_or_driver(args,argv);
    setup_logger();
  }
  Parameter_Map(){}
  ~Parameter_Map(){
    if(use_check_requested_on_destruction)check_requested();
    setup_logger();
  }
};

#endif