include/root/RooLinkedList.h

0001 /*****************************************************************************
0002  * Project: RooFit                                                           *
0003  * Package: RooFitCore                                                       *
0004  *    File: $Id: RooLinkedList.h,v 1.15 2007/05/11 09:11:30 verkerke Exp $
0005  * Authors:                                                                  *
0006  *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
0007  *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
0008  *                                                                           *
0009  * Copyright (c) 2000-2005, Regents of the University of California          *
0010  *                          and Stanford University. All rights reserved.    *
0011  *                                                                           *
0012  * Redistribution and use in source and binary forms,                        *
0013  * with or without modification, are permitted according to the terms        *
0014  * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
0015  *****************************************************************************/
0016 #ifndef ROO_LINKED_LIST
0017 #define ROO_LINKED_LIST
0018
0019 #include "TObject.h"
0020 #include "RooLinkedListElem.h"
0021 #include "TString.h"
0022
0023 #include <vector>
0024 #include <memory>
0025 #include <unordered_map>
0026
0027 class RooLinkedListIter ;
0028 class RooLinkedListIterImpl ;
0029 class RooFIter;
0030 class TIterator ;
0031 class RooAbsArg ;
0032
0033 /// \cond ROOFIT_INTERNAL
0034
0035 template<class T>
0036 class RooSTLRefCountList;
0037
0038 namespace RooLinkedListImplDetails {
0039     class Chunk;
0040     class Pool;
0041 }
0042
0043 /// \endcond
0044
0045 class RooLinkedList : public TObject {
0046 public:
0047   // Constructor
0048   RooLinkedList(Int_t htsize=0) ;
0049
0050   // Copy constructor
0051   RooLinkedList(const RooLinkedList& other) ;
0052
0053   TObject* Clone(const char* =nullptr) const override {
0054     return new RooLinkedList(*this) ;
0055   }
0056
0057   // Assignment operator
0058   RooLinkedList& operator=(const RooLinkedList& other) ;
0059
0060   Int_t getHashTableSize() const {
0061     // Return size of hash table
0062     return _htableName ? _htableName->size() : 0 ;
0063   }
0064
0065   void setHashTableSize(Int_t size) ;
0066
0067   // Destructor
0068   ~RooLinkedList() override ;
0069
0070   Int_t GetSize() const { return _size ; }
0071   std::size_t size() const { return _size ; }
0072   bool empty() const { return _size == 0 ; }
0073
0074   virtual void Add(TObject* arg) { Add(arg,1) ; }
0075   virtual bool Remove(TObject* arg) ;
0076   TObject* At(int index) const ;
0077   bool Replace(const TObject* oldArg, const TObject* newArg) ;
0078   TIterator* MakeIterator(bool forward = true) const ;
0079   RooLinkedListIter iterator(bool forward = true) const ;
0080   RooFIter fwdIterator() const ;
0081   RooLinkedListIterImpl begin() const;
0082   RooLinkedListIterImpl end() const;
0083   RooLinkedListIterImpl rbegin() const;
0084   RooLinkedListIterImpl rend() const;
0085
0086   void Clear(Option_t *o=nullptr) override ;
0087   void Delete(Option_t *o=nullptr) override ;
0088   TObject* find(const char* name) const ;
0089   RooAbsArg* findArg(const RooAbsArg*) const ;
0090   TObject* FindObject(const char* name) const override ;
0091   TObject* FindObject(const TObject* obj) const override ;
0092   Int_t IndexOf(const char* name) const ;
0093   Int_t IndexOf(const TObject* arg) const ;
0094   TObject* First() const {
0095     return _first ? _first->_arg : nullptr ;
0096   }
0097
0098   // For checking if the list contains an element with a given name from Python.
0099   bool contains(const char* name) const { return find(name); }
0100
0101   void RecursiveRemove(TObject *obj) override;
0102
0103   void Print(const char* opt) const override ;
0104   void Sort(bool ascend=true) ;
0105
0106   // const char* GetName() const { return "" ; /*_name.Data() ; */ }
0107   // void SetName(const char* /*name*/) { /*_name = name ; */ }
0108   const char* GetName() const override { return _name.Data() ;  }
0109   void SetName(const char* name) { _name = name ;  }
0110
0111    void useNptr(bool flag) { _useNptr = flag ; }
0112    // needed for using it in THashList/THashTable
0113
0114    ULong_t  Hash() const override { return _name.Hash(); }
0115
0116 protected:
0117
0118   RooLinkedListElem* createElement(TObject* obj, RooLinkedListElem* elem=nullptr) ;
0119   void deleteElement(RooLinkedListElem*) ;
0120
0121   /// \cond ROOFIT_INTERNAL
0122   template<class T> friend class RooSTLRefCountList;
0123   /// \endcond
0124   friend class RooLinkedListIterImpl ;
0125   friend class RooFIterForLinkedList ;
0126
0127   virtual void Add(TObject* arg, Int_t refCount) ;
0128
0129   RooLinkedListElem* findLink(const TObject* arg) const ;
0130
0131   Int_t _hashThresh ;          ///<  Size threshold for hashing
0132   Int_t _size ;                ///<  Current size of list
0133   RooLinkedListElem*  _first ; ///<! Link to first element of list
0134   RooLinkedListElem*  _last ;  ///<! Link to last element of list
0135
0136   using HashTableByName = std::unordered_map<std::string,TObject const*>;
0137   using HashTableByLink = std::unordered_map<TObject const*,TObject const*>;
0138   std::unique_ptr<HashTableByName> _htableName; ///<! Hash table by name
0139   std::unique_ptr<HashTableByLink> _htableLink; ///<! Hash table by link pointer
0140
0141   TString             _name ;
0142   bool              _useNptr ; ///<!
0143
0144 private:
0145   template <bool ascending>
0146   static RooLinkedListElem* mergesort_impl(RooLinkedListElem* l1,
0147      const unsigned sz, RooLinkedListElem** tail = nullptr);
0148   /// memory pool for quick allocation of RooLinkedListElems
0149   typedef RooLinkedListImplDetails::Pool Pool;
0150   /// shared memory pool for allocation of RooLinkedListElems
0151   static Pool* _pool; //!
0152
0153   std::vector<RooLinkedListElem *> _at; ///<! index list for quick index through ::At
0154
0155   ClassDefOverride(RooLinkedList,3) // Doubly linked list for storage of RooAbsArg objects
0156 };
0157
0158 #endif