KVNameValueList.h

 
#ifndef __KVNAMEVALUELIST_H
#define __KVNAMEVALUELIST_H
 
#include "KVHashList.h"
#include "TNamed.h"
#include "TRegexp.h"
#include "KVNamedParameter.h"
class KVEnv;
 
class KVNameValueList : public TNamed {
protected:
    KVHashList fList;
   Bool_t fIgnoreBool = kFALSE; //do not convert "yes", "false", "on", etc. in TEnv file to boolean
 
public:
   KVNameValueList();
   KVNameValueList(std::initializer_list<KVNamedParameter>);
   KVNameValueList(const Char_t* name, const Char_t* title = "");
   KVNameValueList(const KVNameValueList&);
   KVNameValueList(KVNameValueList&&) = default;
 
   KVNameValueList& operator=(const KVNameValueList&);
   KVNameValueList& operator=(KVNameValueList&&) = default;
 
   class Iterator {
   public:
      typedef std::forward_iterator_tag iterator_category;
      typedef KVNamedParameter value_type;
      typedef std::ptrdiff_t difference_type;
      typedef KVNamedParameter* pointer;
      typedef KVNamedParameter& reference;
   private:
      TIter fIter;// iterator over hash list
      KVNamedParameter* current() const
      {
         return reinterpret_cast<KVNamedParameter*>(*fIter);
      }
 
   public:
      Iterator()
         : fIter(static_cast<TIterator*>(nullptr))
      {}
      Iterator(const Iterator& other)
         : fIter(other.fIter)
      {}
      Iterator(const KVNameValueList* N)
         : fIter(N->GetList())
      {
         fIter.Begin();
      }
      Iterator(const KVNameValueList& N)
         : fIter(N.GetList())
      {
         fIter.Begin();
      }
      KVNamedParameter& operator* () const
      {
 
         return *(current());
      }
      Bool_t operator!= (const Iterator& it) const
      {
         return current() != it.current();
      }
      Bool_t operator== (const Iterator& it) const
      {
         return current() == it.current();
      }
      const Iterator& operator++ ()
      {
         ++fIter;
         return *this;
      }
      Iterator operator++ (int)
      {
         Iterator tmp(*this);
         operator++();
         return tmp;
      }
      Iterator& operator= (const Iterator& rhs)
      {
         if (this != &rhs) { // check self-assignment based on address of object
            fIter = rhs.fIter;
         }
         return *this;
      }
      static Iterator End()
      {
         return Iterator();
      }
      virtual ~Iterator() {}
 
      ClassDef(Iterator, 0) //Iterator for KVNameValueList
   };
   Iterator begin() const
   {
      return Iterator(this);
   }
   Iterator end() const
   {
      return Iterator::End();
   }
 
   bool Set(const KVString&);
   KVString Get() const;
 
   KVHashList* GetList() const;
 
   void Clear(Option_t* opt = "") override;
   virtual void ClearSelection(const TRegexp&);
   void Print(Option_t* opt = "") const override;
   TString List(Option_t* opt = "") const;
   void ls(Option_t* opt = "") const override;
 
   void Copy(TObject& nvl) const override;
   Int_t Compare(const TObject* nvl) const override;
 
   template<typename value_type>
   void SetValue(const Char_t* name, value_type value)
   {
      KVNamedParameter* par = FindParameter(name);
      par ? par->Set(name, value) : fList.Add(new KVNamedParameter(name, value));
   }
   void SetValue(const KVNamedParameter&);
   void SetValue64bit(const Char_t* name, ULong64_t);
   ULong64_t GetValue64bit(const Char_t* name) const;
   Bool_t HasValue64bit(const Char_t* name) const;
 
   template <typename value_type>
   void SetValueAt(const Char_t* name, value_type value, Int_t idx)
   {
      KVNamedParameter* par = FindParameter(name);
      if (par) {
         par->Set(value);
         if (fList.IndexOf(par) != idx) {
            fList.GetCollection()->Remove(par);
            fList.AddAt(par, idx);
         }
      }
      else fList.AddAt(new KVNamedParameter(name, value), idx);
   }
 
   template <typename value_type>
   void SetFirstValue(const Char_t* name, value_type value)
   {
      KVNamedParameter* par = FindParameter(name);
      if (par) {
         par->Set(value);
         if (fList.First() != par) {
            fList.GetCollection()->Remove(par);
            fList.AddFirst(par);
         }
      }
      else fList.AddFirst(new KVNamedParameter(name, value));
   }
 
   template <typename value_type>
   void SetLastValue(const Char_t* name, value_type value)
   {
      KVNamedParameter* par = FindParameter(name);
      if (par) {
         par->Set(value);
         if (fList.Last() != par) {
            fList.GetCollection()->Remove(par);
            fList.AddLast(par);
         }
      }
      else fList.AddLast(new KVNamedParameter(name, value));
   }
 
   template <typename value_type>
   void IncrementValue(const Char_t* name, value_type value)
   {
      KVNamedParameter* par = FindParameter(name);
      par ? par->Add(KVNamedParameter(name, value)) : fList.Add(new KVNamedParameter(name, value));
   }
 
   template <typename value_type>
   Bool_t IsValue(const Char_t* name, value_type value) const
   {
      KVNamedParameter* par = FindParameter(name);
      if (par) {
         KVNamedParameter tmp(name, value);
         return (*par) == tmp;
      }
      return kFALSE;
   }
 
   KVNamedParameter* FindParameter(const Char_t* name) const;
   KVNamedParameter* GetParameter(Int_t idx) const;
   void RemoveParameter(const Char_t* name);
   Bool_t HasParameter(const Char_t* name) const;
   template <typename value_type>
   Bool_t HasParameter(const Char_t* name) const
   {
 
      KVNamedParameter* p = FindParameter(name);
      return (p && p->Is<value_type>());
   }
   Bool_t HasIntParameter(const Char_t* name) const
   {
      return HasParameter<int>(name);
   }
   Bool_t HasBoolParameter(const Char_t* name) const
   {
      return HasParameter<bool>(name);
   }
   Bool_t HasDoubleParameter(const Char_t* name) const
   {
      return HasParameter<double>(name);
   }
   Bool_t HasStringParameter(const Char_t* name) const
   {
      return HasParameter<TString>(name);
   }
   Bool_t HasNumericParameter(const Char_t* name) const
   {
      return (HasIntParameter(name) || HasDoubleParameter(name)) || (HasStringParameter(name) && GetTStringValue(name).IsFloat());
   }
   Int_t GetNameIndex(const Char_t* name) const;
   const Char_t* GetNameAt(Int_t idx) const;
   Int_t GetNpar() const;
   Int_t GetEntries() const
   {
      return GetNpar();
   }
   Bool_t IsEmpty() const
   {
      return GetNpar() == 0;
   }
 
   KVNamedParameter& operator[](const TString& name) const
   {
      KVNamedParameter* par = FindParameter(name);
      if (!par)
         throw std::runtime_error(Form("KVNameValueList::operator[](const TString&): no parameter with name '%s' in list", name.Data()));
      return *par;
   }
   template <typename value_type>
   value_type GetValue(const Char_t* name) const
   {
 
      KVNamedParameter* par = FindParameter(name);
      return (par ? par->Get<value_type>() : KVNamedParameter::DefaultValue<value_type>());
   }
 
   Int_t GetIntValue(const Char_t* name) const
   {
      return GetValue<int>(name);
   }
   Bool_t GetBoolValue(const Char_t* name) const
   {
      return GetValue<bool>(name);
   }
   Double_t GetDoubleValue(const Char_t* name) const
   {
      return GetValue<double>(name);
   }
   const Char_t* GetStringValue(const Char_t* name) const
   {
      return GetValue<cstring>(name);
   }
   TString GetTStringValue(const Char_t* name) const;
 
   template <typename value_type>
   value_type GetValue(Int_t idx) const
   {
      KVNamedParameter* par = GetParameter(idx);
      return (par ? par->Get<value_type>() : KVNamedParameter::DefaultValue<value_type>());
   }
 
   Int_t GetIntValue(Int_t idx) const
   {
      return GetValue<int>(idx);
   }
   Bool_t GetBoolValue(Int_t idx) const
   {
      return GetValue<bool>(idx);
   }
   Double_t GetDoubleValue(Int_t idx) const
   {
      return GetValue<double>(idx);
   }
   const Char_t* GetStringValue(Int_t idx) const
   {
      return GetValue<cstring>(idx);
   }
   TString GetTStringValue(Int_t idx) const;
 
   virtual void ReadEnvFile(const Char_t* filename);
   void ReadEnv(const TEnv&);
   std::unique_ptr<KVEnv> ProduceEnvFile();
   virtual void WriteEnvFile(const Char_t* filename);
 
   void Sort(Bool_t order = kSortAscending)
   {
      fList.Sort(order);
   }
 
   void Concatenate(const KVNameValueList& nvl);
 
   void WriteClass(const Char_t* classname, const Char_t* classdesc, const Char_t* base_class = "");
 
   void SetIgnoreBool(Bool_t ignore = kTRUE)
   {
      fIgnoreBool = ignore;
   }
   void SetFromEnv(TEnv* tenv, const TString& prefix = "");
   void WriteToEnv(TEnv* tenv, const TString& prefix = "");
   void Merge(const KVNameValueList&);
   void AddValue(const KVNamedParameter& p);
 
   TString AsSQLSelection() const;
 
   ClassDefOverride(KVNameValueList, 4) //A general-purpose list of parameters
};
#endif