KVSeqCollection.h

 
#ifndef __KVSEQCOLLECTION_H
#define __KVSEQCOLLECTION_H
 
#include "TSeqCollection.h"
#include <RQ_OBJECT.h>
#include "TFile.h"
#include "KVConfig.h"
#include "KVError.h"
 
 
class KVSeqCollection : public TSeqCollection {
   RQ_OBJECT("KVSeqCollection")
 
   enum {
      kSignals = BIT(15), // bit flag for sending 'Modified()' signal on changes
      kCleanup = BIT(17) // set when objects in list are in ROOT cleanup list
   };
 
    static Long64_t fSCCounter;
   void init();
    static Int_t fgCounter;
    static TSeqCollection* fgCleanups;
 
protected:
    TSeqCollection* fCollection;
 
   void Changed() override
   {
 
      TSeqCollection::Changed();
      if (TestBit(kSignals)) Modified();
   };
   void  PrintCollectionHeader(Option_t* option) const override;
   KVSeqCollection* NewCollectionLikeThisOne() const;
   void SetCollection(const TString&);
   virtual void _GetSubListWithMethod(KVSeqCollection*, TCollection*, const Char_t*, const Char_t*) const;
   void _GetSubListWithClass(KVSeqCollection*, TCollection*, const TClass*) const;
   void set_ownership(Bool_t enable)
   {
      TSeqCollection::SetOwner(enable);
      fCollection->SetOwner(enable);
   }
 
public:
   KVSeqCollection();
   KVSeqCollection(const KVSeqCollection&);
   KVSeqCollection(KVSeqCollection&&);
   KVSeqCollection(const TString& collection_classname);
   virtual ~KVSeqCollection();
   void Copy(TObject& obj) const override;
   KVSeqCollection& operator=(const KVSeqCollection&);
   KVSeqCollection& operator=(KVSeqCollection&&);
 
   virtual void Modified()
   {
      Emit("Modified()");
   }  // *SIGNAL*
   virtual void SendModifiedSignals(Bool_t yes = kTRUE)
   {
      SetBit(kSignals, yes);
   }
   virtual Bool_t IsSendingModifiedSignals() const
   {
      return TestBit(kSignals);
   }
 
   TObject* At(Int_t idx) const override
   {
      return fCollection->At(idx);
   }
   void      AddFirst(TObject* obj) override
   {
 
      if (IsCleanup()) obj->SetBit(kMustCleanup);
      fCollection->AddFirst(obj);
      Changed();
   }
   void      AddLast(TObject* obj) override
   {
 
      if (IsCleanup()) obj->SetBit(kMustCleanup);
      fCollection->AddLast(obj);
      Changed();
   }
   void      AddAt(TObject* obj, Int_t idx) override
   {
 
      if (IsCleanup()) obj->SetBit(kMustCleanup);
      fCollection->AddAt(obj, idx);
      Changed();
   }
   void      AddAfter(const TObject* after, TObject* obj) override
   {
 
      if (IsCleanup()) obj->SetBit(kMustCleanup);
      fCollection->AddAfter(after, obj);
      Changed();
   }
   void      AddBefore(const TObject* before, TObject* obj) override
   {
 
      if (IsCleanup()) obj->SetBit(kMustCleanup);
      fCollection->AddBefore(before, obj);
      Changed();
   }
   TObject*  Before(const TObject* obj) const override
   {
      return fCollection->Before(obj);
   }
   TObject*  After(const TObject* obj) const override
   {
      return fCollection->After(obj);
   }
   TObject*  First() const override
   {
      return fCollection->First();
   }
   TObject*  Last() const override
   {
      return fCollection->Last();
   }
   void       Add(TObject* obj) override
   {
 
      if (IsCleanup()) obj->SetBit(kMustCleanup);
      fCollection->Add(obj);
      Changed();
   }
   void       Clear(Option_t* option = "") override;
   void       Delete(Option_t* option = "") override;
   TObject**  GetObjectRef(const TObject* obj) const override;
   TIterator* MakeIterator(Bool_t dir = kIterForward) const override;
   TObject*   Remove(TObject* obj) override;
   void RecursiveRemove(TObject* obj) override;
   Int_t GetSize() const override
   {
      return fCollection ? fCollection->GetSize() : 0;
   }
   void SetOwner(Bool_t enable = kTRUE) override
   {
      set_ownership(enable);
   }
   TString CollectionClassName() const
   {
      return fCollection->ClassName();
   }
   virtual void SetCleanup(Bool_t enable = kTRUE);
   Bool_t IsCleanup() const
   {
      return TestBit(kCleanup);
   }
   static void RehashCleanupList();
 
   TObject* FindObject(const char* name) const override
   {
      return fCollection->FindObject(name);
   }
   template
   <typename T>
   T* get_object(const TString& name) const
   {
      return dynamic_cast<T*>(FindObject(name));
   }
   TObject* FindObject(const TObject* obj) const override
   {
      return fCollection->FindObject(obj);
   }
   virtual TObject* FindObjectByName(const Char_t* name) const
   {
      return fCollection->FindObject(name);
   }
   virtual TObject* FindObjectByType(const Char_t*) const;
   virtual TObject* FindObjectByTitle(const Char_t*) const;
   TObject* FindObjectByClass(const Char_t*) const;
   TObject* FindObjectByClass(const TClass*) const;
   virtual TObject* FindObjectByLabel(const Char_t*) const;
   virtual TObject* FindObjectByNumber(UInt_t num) const;
   virtual TObject* FindObjectWithNameAndType(const Char_t* name, const Char_t* type) const;
   virtual TObject* FindObjectWithMethod(const Char_t* retvalue, const Char_t* method) const;
   virtual TObject* FindObjectAny(const Char_t* att, const Char_t* keys, Bool_t contains_all = kFALSE, Bool_t case_sensitive = kTRUE) const;
 
#ifdef __WITHOUT_TCOLLECTION_GETENTRIES
   Int_t GetEntries() const override
   {
      return GetSize();
   };
#endif
   void Execute(const char* method, const char* params,
                Int_t* error = 0) override;
   void Execute(TMethod* method, TObjArray* params,
                Int_t* error = 0) override;
   KVSeqCollection* GetSubListWithMethod(const Char_t* retvalue, const Char_t* method) const;
 
   KVSeqCollection* GetSubListWithClass(const TClass* _class) const;
   KVSeqCollection* GetSubListWithClass(const Char_t* class_name) const;
 
   KVSeqCollection* GetSubListWithName(const Char_t* retvalue) const;
   KVSeqCollection* GetSubListWithLabel(const Char_t* retvalue) const;
   KVSeqCollection* GetSubListWithType(const Char_t* retvalue) const;
 
   static KVSeqCollection* MakeListFromFile(TFile* file);
   static KVSeqCollection* MakeListFromFileWithMethod(TFile* file, const Char_t* retvalue, const Char_t* method);
   static KVSeqCollection* MakeListFromFileWithClass(TFile* file, const TClass* _class);
   static KVSeqCollection* MakeListFromFileWithClass(TFile* file, const Char_t* class_name);
 
   Bool_t IsSortable() const override
   {
      return fCollection->IsSortable();
   }
   Bool_t IsSorted() const override
   {
      return fCollection->IsSorted();
   }
 
   TSeqCollection* GetCollection() const
   {
      return fCollection;
   }
   Bool_t operator!() const
   {
      return IsEmpty();
   }
   template<typename ObjectType, typename ValueType>
   ValueType GetSumOverCollection(std::function<ValueType(const ObjectType*)> Function) const
   {
 
      ValueType v = ValueType{0};
      for(auto p : *this)
      {
         auto q = dynamic_cast<const ObjectType*>(p);
         if(q)
            v += Function(q);
      }
      return v;
   }
 
   ClassDefOverride(KVSeqCollection, 3) //KaliVeda extensions to ROOT collections
};
 
#if ROOT_VERSION_CODE < ROOT_VERSION(5,11,2)
 
 
 
#define R__FOR_EACH(type,proc) \
   SetCurrentCollection(); \
   TIter _NAME3_(nxt_,type,proc)(TCollection::GetCurrentCollection()); \
   type *_NAME3_(obj_,type,proc); \
   while ((_NAME3_(obj_,type,proc) = (type*) _NAME3_(nxt_,type,proc)())) \
      _NAME3_(obj_,type,proc)->proc
 
#endif
 
#endif