KVAvailableRunsFile.h

/*
$Id: KVAvailableRunsFile.h,v 1.5 2008/02/07 09:25:39 franklan Exp $
$Revision: 1.5 $
$Date: 2008/02/07 09:25:39 $
*/
 
 
#ifndef __KVAVAILABLERUNSFILE_H
#define __KVAVAILABLERUNSFILE_H
 
#include <forward_list>
#include <optional>
 
#include <KVBase.h>
#include "Riostream.h"
 
#include "TDatime.h"
#include "TString.h"
#include "KVNumberList.h"
#include "KVLockfile.h"
#include "KVDatime.h"
#include "KVDataSet.h"
#include "KVList.h"
#include "KVUnownedList.h"
#include "KVHashList.h"
#include "KVNameValueList.h"
#include "TSystem.h"
#ifdef WITH_RSQLITE
#include "SQLiteDB.h"
using DataBase = KVSQLite::database;
#else
using DataBase = TObject;
#endif
#include "run_index.h"
 
class KVDBSystem;
class TList;
 
class KVAvailableRunsFile: public KVBase {
 
    static KVString date_read_from_filename;
   const KVDataSet* fDataSet = nullptr;         
private:
   TString SelectRunAndOrIndex(const run_index_t& run)
   {
      TString selection = Form("run = %d", run.run());
      if (run.has_index()) selection += Form(" AND index = %d", run.index());
      else selection += " AND index IS NULL";
      return selection;
   }
   TString SelectFileName(const KVString& filename)
   {
      return "filename = '" + filename + "'";
   }
   bool insert_runfile_into_database(KVDataRepository* repository,
                                     const KVBase* objs,
                                     DataBase* RunListTable,
                                     const run_index_t& run_num,
                                     KVDBRun* run, bool with_version_and_username = false);
   void insert_runfile_into_database(KVDataRepository* repository,
                                     const KVString& filename,
                                     const KVDatime& modt,
                                     DataBase* RunListTable,
                                     const run_index_t& run_num,
                                     KVDBRun* run, bool with_version_and_username = false);
 
protected:
   KVString GetFileName() const;
   KVString GetFilePath() const;
   KVString GetFullPathToAvailableRunsFile() const;
   Bool_t CheckDirectoryForAvailableRunsFile();
   virtual std::unique_ptr<DataBase> OpenAvailableRunsFile(bool called_by_update = false);
   bool making_new_db = false;
 
   virtual bool get_file_modification_date(KVDataRepository* repository, const KVBase* objs, KVDatime& modt);
public:
   KVAvailableRunsFile() = default;
   KVAvailableRunsFile(const Char_t* type): KVBase(type)
   {
   }
   KVAvailableRunsFile(const Char_t* type, const KVDataSet* parent): KVBase(type), fDataSet{parent}
   {
   }
 
   Bool_t FileExists() const
   {
      return !gSystem->AccessPathName(GetFullPathToAvailableRunsFile());
   }
 
   const Char_t* GetDataType() const
   {
      return GetName();
   }
   std::optional<run_index_t> IsRunFileName(const Char_t* filename);
   static std::optional<run_index_t> IsRunFileName(const KVString& fmt, const KVString& filename, const KVString& separators = ".");
   Bool_t ExtractDateFromFileName(const Char_t* name, KVDatime& date)
   {
 
      TString fmt = fDataSet->GetDataSetEnv(Form("DataSet.RunFileName.%s", GetDataType()));
      return ExtractDateFromFileName(fmt, name, date);
   }
   static Bool_t ExtractDateFromFileName(const TString& fmt, const Char_t* name, KVDatime& date);
   virtual void Update(const std::unique_ptr<DataBase>& db_handle = {});
   Bool_t CheckAvailable(const run_index_t& run)
   {
#ifdef WITH_RSQLITE
      auto RunDB = OpenAvailableRunsFile();
 
      return (RunDB->count("Available_Runs", "*", SelectRunAndOrIndex(run), true) > 0);
#else
      return false;
#endif
   }
   Int_t Count(const run_index_t& run)
   {
#ifdef WITH_RSQLITE
      auto RunDB = OpenAvailableRunsFile();
 
      return RunDB->count("Available_Runs", "*", SelectRunAndOrIndex(run));
#else
      return 0;
#endif
   }
   Bool_t GetRunInfo(const run_index_t& run, TDatime& modtime,
                     TString& filename);
   void GetRunInfos(const run_index_t& run, KVList& dates, KVList& names);
#ifdef WITH_RSQLITE
   using runfile_info_t = std::pair<KVDatime, TString>;
   std::vector<runfile_info_t> GetRunInfos(const run_index_t& run);
   std::map<run_index_t, std::vector<runfile_info_t>> GetRunFileInfos(const run_index_list& runlist);
   void PrintRunFileInfos(const run_index_list& runlist);
#endif
   TString GetFileName(const run_index_t& run)
   {
 
      TString fname;
      TDatime dtime;
      GetRunInfo(run, dtime, fname);
      return fname;
   }
   KVList GetListOfAvailableRunFilesForSystem(const KVDBSystem* systol);
   KVUnownedList GetListOfAvailableSystems();
   KVUniqueNameList GetSystemsForRunFiles(const run_index_list& rl) const;
   run_index_list GetRunList(const KVDBSystem* system = 0);
 
   virtual void Remove(const run_index_t& run, const KVString& filename = "");
   void UpdateInfos(const run_index_t& run, const KVString& filename, const KVString& kvversion, const KVString& username);
   Bool_t InfosNeedUpdate(const run_index_t& run, const KVString& filename);
   virtual void Add(const run_index_t& run, const KVString& filename);
   const KVDataSet* GetDataSet() const
   {
      return fDataSet;
   }
 
   void SetDataSet(const KVDataSet* d)
   {
      fDataSet = d;
   }
 
   std::forward_list<run_index_t> CheckMultiRunfiles();
   void RemoveDuplicateLines(KVNumberList lines_to_be_removed);
 
   ClassDef(KVAvailableRunsFile, 1)     //Handles text files containing list of available runs for different datasets and types of data
};
 
#endif