DB.hh

 
#ifndef __RAT_DB__
#define __RAT_DB__
 
#include <RAT/DBFieldCallback.hh>
#include <RAT/DBTable.hh>
#include <RAT/HTTPDownloader.hh>
#include <RAT/Log.hh>
#include <deque>
#include <limits>
#include <list>
#include <map>
#include <set>
#include <smart_ptr.hpp>
#include <string>
 
namespace RAT {
 
class DB;  // Forward decl to allow for static DB member inside itself
class DBTable;
class DBLink;
 
class DBTableKey {
 public:
  DBTableKey() : name(""), index(""), run(0){};
  DBTableKey(const std::string &_name, const std::string &_index, const int _run = 0)
      : name(_name), index(_index), run(_run){};
 
  std::string name;
  std::string index;
  int run;
 
  bool operator<(const DBTableKey &rhs) const {
    return (name < rhs.name) || (name == rhs.name && index < rhs.index) ||
           (name == rhs.name && index == rhs.index && run < rhs.run);
  };
 
  bool operator==(const DBTableKey &rhs) const {
    return (name == rhs.name) && (index == rhs.index) && (run == rhs.run);
  };
};
 
typedef std::map<DBTableKey, simple_ptr_nocopy<DBTable>> DBTableSet;
typedef simple_ptr_nocopy<DBLink> DBLinkPtr;
typedef std::map<std::string, DBLinkPtr> DBLinkGroup;
 
class DB : public DBFieldCallback {
 public:
  static inline DB *Get() { return primary == 0 ? primary = new DB : primary; };
 
  static bool ParseTableName(std::string descriptor, std::string &table, std::string &index);
 
  static std::vector<RAT::DBTable *> ReadRATDBFile(const std::string &filename);
 
 protected:
  static DB *primary;
 
 public:
  DB();
  virtual ~DB();
 
  int Load(std::string filename, bool printPath = false);
 
  int LoadTable(DBTable *table);
 
  int LoadFile(std::string filename);
 
  int LoadAll(std::string dirname, std::string pattern = "*.ratdb");
 
  int LoadDefaults();
 
  void Clear();
 
  void SetServer(std::string url);
 
  void SetDefaultRun(int _run);
 
  int GetDefaultRun() const;
 
  DBLinkPtr GetLink(std::string tblname, std::string index = "");
 
  DBLinkPtr GetLink(std::string tblname, std::string index, int run);
 
  DBLinkGroup GetLinkGroup(std::string tblname);
 
  // Manually set fields on the user plane.  Also for user use.
  // DO THIS AFTER loading files from disk, or your changes will be
  // stomped on later.
 
  const DBTableSet &GetAllTables() { return tables; };
 
  template <typename T>
  void Set(const std::string &tblname, const std::string &fieldname, const T &val);
 
  template <typename T>
  void Set(const std::string &tblname, const std::string &index, const std::string &fieldname, const T &val);
 
  template <typename T>
  void SetArrayIndex(const std::string &tblname, const std::string &fieldname, size_t idx, const T &val);
 
  template <typename T>
  void SetArrayIndex(const std::string &tblname, const std::string &index, const std::string &fieldname, size_t idx,
                     const T &val);
 
  static constexpr int kUseDefaultRun = std::numeric_limits<int>::min();
 
  void DumpContentsToJson(std::ostream &stream, int run = kUseDefaultRun);
 
  /************************DBLink interface********************/
  // This is the low level interface that DBLinks use.
  // You should not call these methods.
 
  DBTable *GetUserTable(std::string tblname, std::string index) { return FindTable(tblname, index, -1); };
 
  DBTable *GetRunTable(std::string tblname, std::string index, int runNumber) {
    return FindTable(tblname, index, runNumber);
  };
 
  DBTable *GetDefaultTable(std::string tblname, std::string index) { return FindTable(tblname, index, 0); };
 
  void RemoveLink(DBLink *link);
 
  int NumLinks() { return links.size(); };
 
  virtual std::vector<int> FetchIArray(const std::string &tableID, const std::string &fieldname);
  virtual std::vector<double> FetchDArray(const std::string &tableID, const std::string &fieldname);
 
 protected:
  DBTable *FindTable(std::string tblname, std::string index, int runNumber);
 
  DBTable *FindOrCreateTable(std::string tblname, std::string index, int runNumber);
 
  std::list<RAT::DBLink *> links;
 
  std::string server;
 
  std::set<std::string> tableNamesOnServer;
 
  std::set<RAT::DBTableKey> tablesNotOnServer;
 
  HTTPDownloader downloader;
 
  DBTableSet tables;
 
  std::deque<std::pair<RAT::DBTableKey, bool>> tablesFromServer;
 
  int run;
};
 
}  // namespace RAT
 
// Unfortunately necessary to include this after definition of DB to avoid
// circular references
#include <RAT/DBLink.hh>
 
template <typename T>
void RAT::DB::Set(const std::string &tblname, const std::string &fieldname, const T &val) {
  Set(tblname, "", fieldname, val);
}
 
template <typename T>
void RAT::DB::Set(const std::string &tblname, const std::string &index, const std::string &fieldname, const T &val) {
  DBTable *t = FindOrCreateTable(tblname, index, -1);
  t->Set(fieldname, val);
}
 
template <typename T>
void RAT::DB::SetArrayIndex(const std::string &tblname, const std::string &fieldname, size_t idx, const T &val) {
  SetArrayIndex(tblname, "", fieldname, idx, val);
}
 
template <typename T>
void RAT::DB::SetArrayIndex(const std::string &tblname, const std::string &index, const std::string &fieldname,
                            size_t idx, const T &val) {
  DBTable *t = FindOrCreateTable(tblname, index, -1);
  DBLinkPtr p = GetLink(tblname,
                        index);  // This ensures we always grab either the previously set
                                 // or default plane array without keeping track explicitly
  json::Value jval = p->Get<json::Value>(fieldname);
  Log::Assert(jval.getType() == json::TARRAY, "RATDB: Cannot set an index for an item that is not an array!");
  jval[index] = val;
  t->Set(fieldname, jval);
}
 
#endif