KVRunListLine.h

 
#ifndef __KVRUNLISTLINE_H
#define __KVRUNLISTLINE_H
 
#include "TObjString.h"
#include "TObjArray.h"
#include "Riostream.h"
#include "KVNameValueList.h"
#include "KVString.h"
#include "KVList.h"
 
class KVRunListLine {
 
private:
    Int_t fMaxNFields;
    TString fLine;
    Bool_t fFieldsSet;
    TObjArray* fFields;
    KVList fFieldKeys;
    KVList fRunKeys;
 
   inline Int_t GetFieldIndex(const Char_t*) const;
 
    bool calling_field_keys;
    bool calling_run_keys;
   void SetFieldKeys()
   {
      calling_field_keys = false;   // just to terminate recursion of parameter pack
   }
   void SetRunKeys()
   {
      calling_run_keys = false;   // just to terminate recursion of parameter pack
   }
 
protected:
    KVNameValueList fIndexList;
 
public:
   KVRunListLine();
   virtual ~ KVRunListLine();
 
   virtual const Char_t* GetField(const Char_t*) const;
   TObjString* GetFieldString(const Char_t*) const;
   Int_t GetIntField(const Char_t*);
   Float_t GetFloatField(const Char_t*);
 
   virtual void SetFields();
   Bool_t FieldsSet() const
   {
      return fFieldsSet;
   };
 
   inline void SetLine(const Char_t*);
   inline void SetLine(TString&);
   inline void Clear();
   Int_t BreakLineIntoFields(const char);
   inline Bool_t HasFieldValue(const Char_t*) const;
   inline Bool_t HasField(const Char_t*) const;
   Bool_t FieldContains(const Char_t*, const Char_t*) const;
   Bool_t IsFloat(const Char_t* name);
 
   virtual void Print() const;
   inline void PrintFieldValue(const Char_t* name) const;
   virtual Int_t GetTrigger(const Char_t* field_name =
                               "Trigger", const Char_t* fmt = "M>=%d");
 
   template<typename T, typename... Args>
   void SetFieldKeys(T key0, Args... keys)
   {
 
      if (!calling_field_keys) {
         fFieldKeys.Clear();
         calling_field_keys = true; // to avoid clearing in every recursion
      }
      fFieldKeys.Add(new TObjString(key0));
      SetFieldKeys(keys...);
   }
   template<typename T, typename... Args>
   void SetRunKeys(T key0, Args... keys)
   {
 
      if (!calling_run_keys) {
         fRunKeys.Clear();
         calling_run_keys = true; // to avoid clearing in every recursion
      }
 
      fRunKeys.Add(new TObjString(key0));
      SetRunKeys(keys...);
   }
 
   virtual Bool_t IsFieldHeader();
   virtual Bool_t GoodRunLine();
 
   ClassDef(KVRunListLine, 0)  //Base class for reading runlist files
};
 
 
inline Bool_t KVRunListLine::HasField(const Char_t* fname) const
{
 
   return (FieldsSet() ? fIndexList.HasParameter(fname) : kFALSE);
}
 
 
inline Bool_t KVRunListLine::HasFieldValue(const Char_t* fname) const
{
   Int_t index = GetFieldIndex(fname);
   if (!(index > -1 && index < fFields->GetEntries()))
      return kFALSE;
   KVString tmp(((TObjString*)(*fFields)[index])->String());
   return !tmp.IsWhitespace();
}
 
 
inline Int_t KVRunListLine::GetFieldIndex(const Char_t* fname) const
{
 
   return fIndexList.GetIntValue(fname);
}
 
 
inline void KVRunListLine::SetLine(const Char_t* line)
{
   fLine = line;
}
 
 
inline void KVRunListLine::SetLine(TString& line)
{
   fLine = line;
}
 
 
inline void KVRunListLine::Clear()
{
 
   fFields->Clear();
}
 
 
inline void KVRunListLine::PrintFieldValue(const Char_t* name) const
{
 
   std::cout << name << " : ";
   if (HasFieldValue(name))
      std::cout << GetField(name) << std::endl;
   else
      std::cout << "[absent]" << std::endl;
}
 
#endif