DBTable.hh

 
#ifndef __RAT_DBTable__
#define __RAT_DBTable__
 
#include <RAT/DBFieldCallback.hh>
#include <RAT/HashFunc.hh>
#include <RAT/json.hh>
#include <algorithm>
#include <hash.hpp>
#include <iterator>
#include <numeric>
#include <string>
#include <vector>
 
namespace RAT {
 
class DBTable {
 public:
  DBTable();
 
  DBTable(json::Value &jsonDoc);
 
  DBTable(std::string tblname, std::string index = "");
 
  ~DBTable();
 
  std::string GetName() const { return tblname; };
  void SetName(std::string _tblname) { tblname = _tblname; };
 
  std::string GetIndex() const { return index; };
  void SetIndex(std::string _index) { index = _index; }
 
  // Validity range methods
 
  int GetRunBegin() const { return run_begin; };
  int GetRunEnd() const { return run_end; };
  std::vector<int> GetValidRuns() const;
 
  bool IsUser() const;
  bool IsDefault() const;
  bool IsValidRun(const int run);
  bool UsesRunList() const { return useRunList; };
 
  void SetRunRange(int _run_begin, int _run_end) {
    run_begin = _run_begin;
    run_end = _run_end;
    useRunList = false;
  }
  void SetRunList(std::vector<int> _run_list);
  void SetUser() { SetRunRange(-1, -1); };
  void SetDefault() { SetRunRange(0, 0); };
 
  // Methods for manipulating the fields in this table
 
  enum FieldType {
    NOTFOUND, 
    INTEGER,
    DOUBLE,
    BOOLEAN,
    STRING,
    INTEGER_ARRAY,
    DOUBLE_ARRAY,
    BOOLEAN_ARRAY,
    STRING_ARRAY,
    EMPTY_ARRAY,
    JSON
  };
 
  FieldType GetFieldType(std::string name) const;
 
  std::vector<std::string> GetFieldList() const;
 
  int GetI(const std::string &name) const;
 
  double GetD(const std::string &name) const;
 
  std::string GetS(const std::string &name) const;
 
  bool GetZ(const std::string &name) const;
 
  std::vector<int> GetIArray(const std::string &name) const;
 
  std::vector<double> GetDArray(const std::string &name) const;
 
  std::vector<std::string> GetSArray(const std::string &name) const;
 
  std::vector<bool> GetZArray(const std::string &name) const;
 
  json::Value GetJSON(const std::string &name) const;
 
  json::Value GetCompleteJSON() { return this->table; }
 
  template <typename T>
  inline T Get(const std::string &name) const;
 
  template <typename T>
  inline void Set(const std::string &name, const T &value) {
    table[name] = value;
  }
 
  void SetIArrayDeferred(std::string name, DBFieldCallback *callback) { iatbl_deferred[name] = callback; };
 
  void SetDArrayDeferred(std::string name, DBFieldCallback *callback) { datbl_deferred[name] = callback; };
 
 protected:
  std::string tblname; 
  std::string index;   
  int run_begin;       
  int run_end;         
  bool useRunList = false;   
  std::vector<int> run_list; 
  json::Value table;
 
  stlplus::hash<std::string, FieldType, pyhash> arrayTypeCache;
 
  stlplus::hash<std::string, RAT::DBFieldCallback *, pyhash> iatbl_deferred;
 
  stlplus::hash<std::string, RAT::DBFieldCallback *, pyhash> datbl_deferred;
};
 
/* Specialization of the above Get<> template */
template <>
inline int DBTable::Get<int>(const std::string &name) const {
  return GetI(name);
}
 
template <>
inline double DBTable::Get<double>(const std::string &name) const {
  return GetD(name);
}
 
template <>
inline std::string DBTable::Get<std::string>(const std::string &name) const {
  return GetS(name);
}
 
template <>
inline bool RAT::DBTable::Get<bool>(const std::string &name) const {
  return GetZ(name);
}
 
template <>
inline std::vector<int> RAT::DBTable::Get<std::vector<int>>(const std::string &name) const {
  return GetIArray(name);
}
 
template <>
inline std::vector<double> RAT::DBTable::Get<std::vector<double>>(const std::string &name) const {
  return GetDArray(name);
}
 
template <>
inline std::vector<std::string> RAT::DBTable::Get<std::vector<std::string>>(const std::string &name) const {
  return GetSArray(name);
}
 
template <>
inline std::vector<bool> RAT::DBTable::Get<std::vector<bool>>(const std::string &name) const {
  return GetZArray(name);
}
 
template <>
inline json::Value RAT::DBTable::Get<json::Value>(const std::string &name) const {
  return GetJSON(name);
}
 
class DBNotFoundError {
 public:
  DBNotFoundError(const std::string &_table, const std::string &_index, const std::string &_field)
      : table(_table), index(_index), field(_field){};
 
  bool operator==(const DBNotFoundError &other) const {
    return table == other.table && index == other.index && field == other.field;
  }
 
  std::string table;
  std::string index;
  std::string field;
};
 
class DBWrongTypeError : public DBNotFoundError {
 public:
  DBWrongTypeError(const std::string &_table, const std::string &_index, const std::string &_field,
                   RAT::DBTable::FieldType _requestedType, RAT::DBTable::FieldType _actualType)
      : DBNotFoundError(_table, _index, _field), requestedType(_requestedType), actualType(_actualType){};
 
  bool operator==(const DBWrongTypeError &other) const {
    return table == other.table && index == other.index && field == other.field &&
           requestedType == other.requestedType && actualType == other.actualType;
  }
 
  RAT::DBTable::FieldType requestedType;
  RAT::DBTable::FieldType actualType;
};
 
}  // namespace RAT
 
#endif