EIC code displayed by LXR master/​include/​root/​RooSTLRefCountList.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:11:27

 /// \cond ROOFIT_INTERNAL
 
 // Author: Stephan Hageboeck, CERN, 12/2018
 /*****************************************************************************
  * Project: RooFit                                                           *
  * Authors:                                                                  *
  *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
  *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
  *                                                                           *
  * Copyright (c) 2000-2005, Regents of the University of California          *
  *                          and Stanford University. All rights reserved.    *
  *                                                                           *
  * Redistribution and use in source and binary forms,                        *
  * with or without modification, are permitted according to the terms        *
  * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
  *****************************************************************************/
 
 #ifndef ROOFIT_ROOFITCORE_INC_ROOSTLREFCOUNTLIST_H_
 #define ROOFIT_ROOFITCORE_INC_ROOSTLREFCOUNTLIST_H_
 
 #include "RooNameReg.h"
 
 #include "Rtypes.h"
 
 #include <vector>
 #include <string>
 #include <algorithm>
 #include <cassert>
 
 class RooLinkedList;
 
 /**
  * \class RooSTLRefCountList
  * The RooSTLRefCountList is a simple collection of **pointers** to the template objects with
  * reference counters.
  * The pointees are not owned, hence not deleted when removed from the collection.
  * Objects can be searched for either by pointer or by name (confusion possible when
  * objects with same name are present). This replicates the behaviour of the RooRefCountList.
  */
 
 template <class T>
 class RooSTLRefCountList {
   public:
     using Container_t = std::vector<T*>;
 
     static constexpr std::size_t minSizeForNamePointerOrdering = 7;
 
     RooSTLRefCountList() {
       // The static _renameCounter member gets connected to the RooNameReg as
       // soon as the first RooSTLRefCountList instance is constructed.
       if(_renameCounter == nullptr) _renameCounter =
         &RooNameReg::renameCounter();
     }
     RooSTLRefCountList(const RooSTLRefCountList&) = default;
     RooSTLRefCountList& operator=(const RooSTLRefCountList&) = default;
     RooSTLRefCountList& operator=(RooSTLRefCountList&&) = default;
 
     virtual ~RooSTLRefCountList() {}
 
     ///Add an object or increase refCount if it is already present. Only compares
     ///pointers to check for existing objects
     void Add(T * obj, std::size_t initialCount = 1) {
       // Nothing to add because `refCount` would be zero.
       if(initialCount == 0) return;
 
       auto foundItem = findByPointer(obj);
 
       if (foundItem != _storage.end()) {
         _refCount[foundItem - _storage.begin()] += initialCount;
       }
       else {
         if(!_orderedStorage.empty()) {
           _orderedStorage.insert(lowerBoundByNamePointer(obj), obj);
         }
         _storage.push_back(obj);
         _refCount.push_back(initialCount);
       }
     }
 
 
     ///Return ref count of item that iterator points to.
     std::size_t refCount(typename Container_t::const_iterator item) const {
       assert(_storage.size() == _refCount.size());
 
       return item != _storage.end() ? _refCount[item - _storage.begin()] : 0;
     }
 
 
     ///Return ref count of item with given address.
     template<typename Obj_t>
     std::size_t refCount(const Obj_t * obj) const {
       return refCount(findByPointer(obj));
     }
 
     ///Iterator over contained objects.
     typename Container_t::const_iterator begin() const {
       return _storage.begin();
     }
 
     ///End of contained objects.
     typename Container_t::const_iterator end() const {
       return _storage.end();
     }
 
     /// Retrieve an element from the list.
     typename Container_t::value_type operator[](std::size_t index) const {
       return _storage[index];
     }
 
 
     ///Direct reference to container of objects held by this list.
     const Container_t& containedObjects() const {
       return _storage;
     }
 
 
     ///Number of contained objects (neglecting the ref count).
     std::size_t size() const {
       assert(_storage.size() == _refCount.size());
 
       return _storage.size();
     }
 
     void reserve(std::size_t amount) {
       _storage.reserve(amount);
       _refCount.reserve(amount);
       _orderedStorage.reserve(amount);
     }
 
 
     ///Check if empty.
     bool empty() const {
       return _storage.empty();
     }
 
 
     ///Find an item by comparing its address.
     template<typename Obj_t>
     typename Container_t::const_iterator findByPointer(const Obj_t * item) const {
       return std::find(_storage.begin(), _storage.end(), item);
     }
 
 
     ///Find an item by comparing strings returned by RooAbsArg::GetName()
     typename Container_t::const_iterator findByName(const char * name) const {
       //If this turns out to be a bottleneck,
       //one could use the RooNameReg to obtain the pointer to the arg's name and compare these
       const std::string theName(name);
       auto byName = [&theName](const T * element) {
         return element->GetName() == theName;
       };
 
       return std::find_if(_storage.begin(), _storage.end(), byName);
     }
 
 
     ///Find an item by comparing RooAbsArg::namePtr() addresses.
     inline T* findByNamePointer(const T * item) const {
       return findByNamePointer(item->namePtr());
     }
 
     T* findByNamePointer(TNamed const* namePtr) const {
       if(size() < minSizeForNamePointerOrdering) {
         auto byNamePointer = [namePtr](const T * element) {
           return element->namePtr() == namePtr;
         };
 
         auto found = std::find_if(_storage.begin(), _storage.end(), byNamePointer);
         return found != _storage.end() ? *found : nullptr;
       } else {
         //As the collection is guaranteed to be sorted by namePtr() address, we
         //can use a binary search to look for `item` in this collection.
         auto first = lowerBoundByNamePointer(namePtr);
         if(first == _orderedStorage.end()) return nullptr;
         if(namePtr != (*first)->namePtr()) return nullptr;
         return *first;
       }
     }
 
 
     ///Check if list contains an item using findByPointer().
     template<typename Obj_t>
     bool containsByPointer(const Obj_t * obj) const {
       return findByPointer(obj) != _storage.end();
     }
 
 
     ///Check if list contains an item using findByNamePointer().
     bool containsByNamePtr(const T * obj) const {
       return findByNamePointer(obj);
     }
 
 
     ///Check if list contains an item using findByName().
     bool containsSameName(const char * name) const {
       return findByName(name) != _storage.end();
     }
 
 
     ///Decrease ref count of given object. Shrink list if ref count reaches 0.
     ///\param obj Decrease ref count of given object. Compare by pointer.
     ///\param force If true, remove irrespective of ref count.
     ///Returns by how much the `refCount` for the element to be removed was
     ///decreased (zero if nothing was removed). If `force == false`, it can
     ///only be zero or one, if `force == true`, it can be the full `refCount`
     ///for that element.
     int Remove(const T * obj, bool force = false) {
       auto item = findByPointer(obj);
 
       if (item != _storage.end()) {
         const std::size_t pos = item - _storage.begin();
 
         const UInt_t origRefCount = _refCount[pos];
 
         if (force || --_refCount[pos] == 0) {
           //gcc4.x doesn't know how to erase at the position of a const_iterator
           //Therefore, erase at begin + pos instead of 'item'
           _storage.erase(_storage.begin() + pos);
           _refCount.erase(_refCount.begin() + pos);
           if(!_orderedStorage.empty()) {
             // For the ordered storage, we could find by name pointer address
             // with binary search, but this will not work anymore if one of the
             // object pointers in this collection is dangling (can happen in
             // RooFit...). However, the linear search by object address is
             // acceptable, because we already do a linear search through
             // _storage at the beginning of Remove().
             _orderedStorage.erase(std::find(_orderedStorage.begin(), _orderedStorage.end(), obj));
           }
           return origRefCount;
         }
         return 1;
       }
 
       return 0;
     }
 
 
     ///Replace an element with a new value, keeping the same `refCount`. Will
     ///return the `refCount` for that element if the replacement succeeded,
     ///otherwise returns zero in case the `oldObj` could not be found in the
     ///collection.
     int Replace(const T * oldObj, T * newObj) {
       auto item = findByPointer(oldObj);
 
       if (item != _storage.end()) {
         const std::size_t pos = item - _storage.begin();
         _storage[pos] = newObj;
         // The content has changed, so the ordered-by-name storage was invalidated.
         _orderedStorage.clear();
         return _refCount[pos];
       }
 
       return 0;
     }
 
 
     ///Remove from list irrespective of ref count.
     void RemoveAll(const T * obj) {
       Remove(obj, true);
     }
 
     static RooSTLRefCountList<T> convert(const RooLinkedList& old);
 
   private:
     //Return an iterator to the last element in this sorted collection with a
     //RooAbsArg::namePtr() address smaller than for `item`.
     inline typename std::vector<T*>::const_iterator lowerBoundByNamePointer(const T * item) const {
       return lowerBoundByNamePointer(item->namePtr());
     }
 
     typename std::vector<T*>::const_iterator lowerBoundByNamePointer(TNamed const* namePtr) const {
 
       //If the _orderedStorage has not been initialized yet or needs resorting
       //for other reasons, (re-)initialize it now.
       if(orderedStorageNeedsSorting() || _orderedStorage.size() != _storage.size()) initializeOrderedStorage();
 
       return std::lower_bound(_orderedStorage.begin(), _orderedStorage.end(), namePtr,
              [](const auto& x, TNamed const* npt) -> bool {
                 return x->namePtr() < npt;
               });
     }
 
     bool orderedStorageNeedsSorting() const {
       //If an RooAbsArg in this collection was renamed, the collection might
       //not be sorted correctly anymore! The solution: every time any RooAbsArg
       //is renamed, the RooNameReg::renameCounter gets incremented. The
       //RooSTLRefCountList keeps track at which value of the counter it has
       //been sorted last. If the counter increased in the meantime, a
       //re-sorting is due.
       return _renameCounterForLastSorting != *_renameCounter;
     }
 
     void initializeOrderedStorage() const {
       _orderedStorage.clear();
       _orderedStorage.reserve(_storage.size());
       for(std::size_t i = 0; i < _storage.size(); ++i) {
         _orderedStorage.push_back(_storage[i]);
       }
       std::sort(_orderedStorage.begin(), _orderedStorage.end(),
               [](auto& a, auto& b) {
                 return a->namePtr() != b->namePtr() ? a->namePtr() < b->namePtr() : a < b;
               });
       _renameCounterForLastSorting = *_renameCounter;
     }
 
     Container_t _storage;
     std::vector<UInt_t> _refCount;
     mutable std::vector<T*> _orderedStorage; //!
     mutable unsigned long _renameCounterForLastSorting = 0; ///<!
 
     // It is expensive to access the RooNameReg instance to get the counter for
     // the renaming operations. That's why we have out own static pointer to
     // the counter.
     static std::size_t const* _renameCounter;
 
     ClassDef(RooSTLRefCountList<T>,3);
 };
 
 template<class T>
 std::size_t const* RooSTLRefCountList<T>::_renameCounter = nullptr;
 
 #endif /* ROOFIT_ROOFITCORE_INC_ROOSTLREFCOUNTLIST_H_ */
 
 /// \endcond

This page was automatically generated by the 2.3.7 LXR engine. The LXR team