KVDBRunFile.h

#pragma once
 
#include "KVBase.h"
#include "KVNameValueList.h"
#include "KVDatime.h"
#include "KVString.h"
#include "run_index.h"
 
#include <TROOT.h>
 
#define KV__GET_INT(__param) return (fParameters.HasIntParameter(__param) ? fParameters.GetIntValue(__param) : 0);
#define KV__GET_ULONG(__param) return (fParameters.HasValue64bit(__param) ? fParameters.GetValue64bit(__param) : 0);
#define KV__GET_DBL(__param) return (fParameters.HasDoubleParameter(__param) ? fParameters.GetDoubleValue(__param) : 0.);
#define KV__GET_STR(__param) return (fParameters.HasStringParameter(__param) ? fParameters.GetStringValue(__param) : "");
#define KV__SET_INT(__param,__val) fParameters.SetValue(__param,__val);
#define KV__SET_ULONG(__param,__val) fParameters.SetValue64bit(__param,__val);
#define KV__SET_DBL(__param,__val) fParameters.SetValue(__param,__val);
#define KV__SET_STR(__param,__val) fParameters.SetValue(__param,__val);
 
class KVDBRunFile : public KVBase {
   KVNameValueList fParameters;//list of named parameters for run
   TDatime fDatime;             
   TString fKVVersion;             
   TString fUserName;             
   Int_t fRun;
   Int_t fIndex = -1;
   bool fBadFile = false;
   Int_t fGlobalRunFileNumber;
 
public:
   KVDBRunFile() = default;
   KVDBRunFile(const KVString& filename, const run_index_t& run_index)
      : KVBase(Form("run_%s", run_index.as_string().Data()), filename),
        fRun(run_index.run()), fIndex(run_index.index())
   {}
 
   Int_t GetRun() const
   {
      return fRun;
   }
   Int_t GetIndex() const
   {
      return fIndex;
   }
   run_index_t GetRunIndex() const
   {
      return {fRun, fIndex};
   }
   Bool_t Has(const Char_t* param, Bool_t check_whitespace = kTRUE) const
   {
      if (check_whitespace && fParameters.HasStringParameter(param)) {
         return !(fParameters.GetTStringValue(param).IsWhitespace());
      }
      return (fParameters.HasIntParameter(param) || fParameters.HasDoubleParameter(param) || fParameters.HasStringParameter(param));
   }
 
   void SetScaler(const Char_t* name, Int_t val)
   {
      KV__SET_INT(name, val)
   }
   Int_t GetScaler(const Char_t* name) const
   {
      KV__GET_INT(name)
   }
   void SetScaler64(const Char_t* name, ULong64_t val)
   {
      KV__SET_ULONG(name, val)
 
   }
   ULong64_t GetScaler64(const Char_t* name) const
   {
      KV__GET_ULONG(name)
   }
   void Set(const Char_t* param, Double_t val)
   {
      KV__SET_DBL(param, val)
   }
   Double_t Get(const Char_t* param) const
   {
      KV__GET_DBL(param)
   }
   void Set(const Char_t* param, const KVString& val)
   {
      KV__SET_STR(param, val)
   }
   const Char_t* GetString(const Char_t* param) const
   {
      KV__GET_STR(param)
   }
   void SetKVVersion(const Char_t* V)
   {
      fKVVersion = V;
   }
   const Char_t* GetKVVersion() const
   {
      return fKVVersion.Data();
   }
   void SetUserName(const Char_t* U)
   {
      fUserName = U;
   }
   const Char_t* GetUserName() const
   {
      return fUserName.Data();
   }
   const TDatime& GetDatime() const
   {
      return fDatime;
   }
   const Char_t* GetDatimeString() const
   {
      return fDatime.AsString();
   }
   void SetDatime(const TDatime& dat)
   {
      dat.Copy(fDatime);
   }
   ULong64_t GetEvents() const
   {
      return GetScaler64("Events");
   }
   Double_t GetTime() const
   {
      return Get("Length (min.)");
   }
   Double_t GetSize() const
   {
      return Get("Size (MB)");
   }
 
   const Char_t* GetStartDate() const
   {
      return GetString("Start Date");
   }
   const Char_t* GetDate() const
   {
      return GetStartDate();
   }
   const Char_t* GetEndDate() const
   {
      return GetString("End Date");
   }
 
   void SetEvents(ULong64_t evt_number)
   {
      SetScaler64("Events", evt_number);
   }
   void SetTime(Double_t time)
   {
      Set("Length (min.)", time);
   }
   void SetSize(Double_t s)
   {
      Set("Size (MB)", s);
   }
 
   void SetStartDate(const KVString& date)
   {
      Set("Start Date", date);
   }
   void SetDate(const KVString& d)
   {
      SetStartDate(d);
   }
   void SetEndDate(const KVString& d)
   {
      Set("End Date", d);
   }
 
   KVString GetFileName() const
   {
      return GetTitle();
   }
 
   void ls(Option_t* = "") const override
   {
      TROOT::IndentLevel();
      std::cout << "runfile=" << run_index_t{fRun, fIndex}.as_string() << "\tevents=" << GetEvents()
                << " start=" << GetStartDate();
      if (IsBad()) std::cout << " (bad)";
      std::cout << std::endl;
      TROOT::IncreaseDirLevel();
      std::cout << fParameters.List("64bit|Events") << std::endl;
      TROOT::DecreaseDirLevel();
   }
   void Print(Option_t* = "") const override
   {
      ls();
   }
   void SetBad(Bool_t is_bad = kTRUE)
   {
      fBadFile = is_bad;
   }
   Bool_t IsBad() const
   {
      return fBadFile;
   }
   const KVNameValueList& GetParameters() const
   {
      return fParameters;
   }
   Int_t GetGlobalRunFileNumber() const
   {
      return fGlobalRunFileNumber;
   }
   void SetGlobalRunFileNumber(Int_t r)
   {
      fGlobalRunFileNumber = r;
   }
 
   ClassDefOverride(KVDBRunFile, 3)
};