ConfigMap.hpp

Go to the documentation of this file.

 
#pragma once
#ifndef _UTILS_CONFIGMAP_HPP_
#define _UTILS_CONFIGMAP_HPP_
#include <map>
#include <vector>
#include <memory>
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>
#include <assert.h>
#include <Utils/IntelliLog.h>
using namespace std;
namespace INTELLI {
class ConfigMap {
 protected:
  std::map<std::string, uint64_t> u64Map;
  std::map<std::string, int64_t> i64Map;
  std::map<std::string, double> doubleMap;
  std::map<std::string, std::string> strMap;
 
  void spilt(const std::string s, const std::string &c, vector<std::string> &v) {
    std::string::size_type pos1, pos2;
    pos2 = s.find(c);
    pos1 = 0;
    while (std::string::npos != pos2) {
      v.push_back(s.substr(pos1, pos2 - pos1));
 
      pos1 = pos2 + c.size();
      pos2 = s.find(c, pos1);
    }
    if (pos1 != s.length())
      v.push_back(s.substr(pos1));
  }
 public:
  ConfigMap() {}
  ~ConfigMap() {}
  void edit(std::string key, uint64_t value) {
    u64Map[key] = value;
  }
  void edit(std::string key, int64_t value) {
    i64Map[key] = value;
  }
  void edit(std::string key, double value) {
    doubleMap[key] = value;
  }
  void edit(std::string key, std::string value) {
    strMap[key] = value;
  }
  bool existU64(std::string key) {
    return (u64Map.count(key) == 1);
  }
  bool existI64(std::string key) {
    return (i64Map.count(key) == 1);
  }
  bool existDouble(std::string key) {
    return (doubleMap.count(key) == 1);
  }
  bool existString(std::string key) {
    return (strMap.count(key) == 1);
  }
  bool exist(std::string key) {
    return existU64(key) || existI64(key) || existDouble(key) || existString(key);
  }
  uint64_t getU64(std::string key) {
    return u64Map.at(key);
  }
  int64_t getI64(std::string key) {
    return i64Map.at(key);
  }
  double getDouble(std::string key) {
    return doubleMap.at(key);
  }
  std::string getString(std::string key) {
    return strMap.at(key);
  }
  std::string toString(std::string separator = "\t", std::string newLine = "\n") {
    std::string str = "key" + separator + "value" + separator + "type" + newLine;
    for (auto &iter : u64Map) {
      std::string col = iter.first + separator + to_string(iter.second) + separator + "U64" + newLine;
      str += col;
    }
    for (auto &iter : i64Map) {
      std::string col = iter.first + separator + to_string(iter.second) + separator + "I64" + newLine;
      str += col;
    }
    for (auto &iter : doubleMap) {
      std::string col = iter.first + separator + to_string(iter.second) + separator + "Double" + newLine;
      str += col;
    }
    for (auto &iter : strMap) {
      std::string col = iter.first + separator + (iter.second) + separator + "String" + newLine;
      str += col;
    }
    return str;
  }
  void cloneInto(ConfigMap &dest) {
    for (auto &iter : u64Map) {
      dest.edit(iter.first, (uint64_t) iter.second);
    }
    for (auto &iter : i64Map) {
      dest.edit(iter.first, (int64_t) iter.second);
    }
    for (auto &iter : doubleMap) {
      dest.edit(iter.first, (double) iter.second);
    }
    for (auto &iter : strMap) {
      dest.edit(iter.first, (std::string) iter.second);
    }
  }
  bool toFile(std::string fname, std::string separator = ",", std::string newLine = "\n") {
    ofstream of;
    of.open(fname);
    if (of.fail()) {
      return false;
    }
    of << toString(separator, newLine);
    of.close();
    return true;
  }
  bool fromFile(std::string fname, std::string separator = ",", std::string newLine = "\n") {
    ifstream ins;
    ins.open(fname);
    assert(separator.data());
    assert(newLine.data());
    if (ins.fail()) {
      return false;
    }
    std::string readStr;
    // cout << "read file\r\n";
    while (std::getline(ins, readStr, newLine.data()[0])) {
      vector<std::string> cols;
      // readStr.erase(readStr.size()-1);
      spilt(readStr, separator, cols);
      // cout<<readStr+"\n";
      if (cols.size() >= 3) {
        istringstream iss(cols[1]);
        if (cols[2] == "U64") {
          uint64_t value;
          iss >> value;
          edit(cols[0], (uint64_t) value);
        } else if (cols[2] == "I64") {
          int64_t value;
          iss >> value;
          edit(cols[0], (int64_t) value);
        } else if (cols[2] == "Double") {
          double value;
          iss >> value;
          edit(cols[0], (double) value);
        } else if (cols[2] == "String") {
          edit(cols[0], (std::string) cols[1]);
        }
      }
    }
    //ins>>readStr;
    ins.close();
    return true;
  }
 
  int64_t tryI64(string key, int64_t defaultValue = 0, bool showWarning = false) {
    int64_t ru = defaultValue;
    if (this->existI64(key)) {
      ru = this->getI64(key);
      // INTELLI_INFO(key + " = " + to_string(ru));
    } else {
      if (showWarning) {
        INTELLI_WARNING("Leaving " + key + " as blank, will use " + to_string(defaultValue) + " instead");
      }
      //  WM_WARNNING("Leaving " + key + " as blank, will use " + to_string(defaultValue) + " instead");
    }
    return ru;
  }
  uint64_t tryU64(string key, uint64_t defaultValue = 0, bool showWarning = false) {
    uint64_t ru = defaultValue;
    if (this->existU64(key)) {
      ru = this->getU64(key);
      // INTELLI_INFO(key + " = " + to_string(ru));
    } else {
      if (showWarning) {
        INTELLI_WARNING("Leaving " + key + " as blank, will use " + to_string(defaultValue) + " instead");
      }
      //  WM_WARNNING("Leaving " + key + " as blank, will use " + to_string(defaultValue) + " instead");
    }
    return ru;
  }
 
  double tryDouble(string key, double defaultValue = 0, bool showWarning = false) {
    double ru = defaultValue;
    if (this->existDouble(key)) {
      ru = this->getDouble(key);
      // INTELLI_INFO(key + " = " + to_string(ru));
    } else {
      if (showWarning) {
        INTELLI_WARNING("Leaving " + key + " as blank, will use " + to_string(defaultValue) + " instead");
      }
      //  WM_WARNNING("Leaving " + key + " as blank, will use " + to_string(defaultValue) + " instead");
    }
    return ru;
  }
  string tryString(string key, string defaultValue = "", bool showWarning = false) {
    string ru = defaultValue;
    if (this->existString(key)) {
      ru = this->getString(key);
      //INTELLI_INFO(key + " = " + (ru));
    } else {
      if (showWarning) {
        INTELLI_WARNING("Leaving " + key + " as blank, will use " + (defaultValue) + " instead");
      }
      // WM_WARNNING("Leaving " + key + " as blank, will use " + (defaultValue) + " instead");
    }
    return ru;
  }
 
};
typedef std::shared_ptr<ConfigMap> ConfigMapPtr;
#define  newConfigMap make_shared<INTELLI::ConfigMap>
}
 
#endif