EIC code displayed by LXR master/​include/​Geant4/​G4FastList.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:58:16

 //
 // ********************************************************************
 // * License and Disclaimer                                           *
 // *                                                                  *
 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
 // * conditions of the Geant4 Software License,  included in the file *
 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
 // * include a list of copyright holders.                             *
 // *                                                                  *
 // * Neither the authors of this software system, nor their employing *
 // * institutes,nor the agencies providing financial support for this *
 // * work  make  any representation or  warranty, express or implied, *
 // * regarding  this  software system or assume any liability for its *
 // * use.  Please see the license in the file  LICENSE  and URL above *
 // * for the full disclaimer and the limitation of liability.         *
 // *                                                                  *
 // * This  code  implementation is the result of  the  scientific and *
 // * technical work of the GEANT4 collaboration.                      *
 // * By using,  copying,  modifying or  distributing the software (or *
 // * any work based  on the software)  you  agree  to acknowledge its *
 // * use  in  resulting  scientific  publications,  and indicate your *
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
 //
 // Author: Mathieu Karamitros
 
 // The code is developed in the framework of the ESA AO7146
 //
 // We would be very happy hearing from you, send us your feedback! :)
 //
 // In order for Geant4-DNA to be maintained and still open-source,
 // article citations are crucial. 
 // If you use Geant4-DNA chemistry and you publish papers about your software, 
 // in addition to the general paper on Geant4-DNA:
 //
 // Int. J. Model. Simul. Sci. Comput. 1 (2010) 157–178
 //
 // we would be very happy if you could please also cite the following
 // reference papers on chemistry:
 //
 // J. Comput. Phys. 274 (2014) 841-882
 // Prog. Nucl. Sci. Tec. 2 (2011) 503-508 
 
 #pragma once
 
 #include "globals.hh"
 #include "G4ReferenceCountedHandle.hh"
 #include <G4memory.hh>
 #include <vector>
 #include <set>
 //#include "G4ManyFastLists.hh"
 
 template<class OBJECT>
   class G4FastList;
 template<class OBJECT>
   class G4FastList_Boundary;
 template<typename OBJECT>
   struct G4FastList_iterator;
 template<typename OBJECT>
   struct G4FastList_const_iterator;
 template<typename OBJECT>
   class G4ManyFastLists;
 template<typename OBJECT>
   struct G4ManyFastLists_iterator;
 template<class OBJECT>
   struct sortWatcher;
 
 
 /** Comments :
  * - A track cannot belong to two different track lists
  * - Erase a given track is constant complexity
  * - This development was thought to be used together with G4IT
  */
 
 #ifndef TYPE_WRAPPER
 #define TYPE_WRAPPER
 template < typename T>
 struct type_wrapper
 {
    using type = T;
 };
 #endif
 
 template<class LIST>
   struct _ListRef
   {
     using traits_type = type_wrapper<LIST>;
     using mli_traits_type = type_wrapper<G4ManyFastLists_iterator<typename LIST::object>>;
 
 //#ifdef WIN32
 //    friend typename traits_type::type;
 //    friend typename traits_type::type::node;
 //    friend typename mli_traits_type::type;
 ////#elif defined(__clang__)
 ////    friend T;
 ////    friend T::node;
 ////    friend G4ManyFastLists_iterator<traits_type::type::object>;
 //#else
 //    friend class traits_type::type;
 //    friend class traits_type::type::node;
 //    friend class mli_traits_type::type;
 //#endif
 
     LIST* fpList;
 
 //  protected:
     inline _ListRef(LIST* __list) :
         fpList(__list)
     {
       ;
     }
  };
 
 /**
  * G4FastListNode is the entity actually stored
  * by the G4FastList. A G4FastListNode should
  * belong only to one list. Also, an object
  * should belong only to one list.
  */
 
 template<class OBJECT>
   class G4FastListNode
   {
     using ObjectW = type_wrapper<OBJECT>;
     using LIST = G4FastList<typename ObjectW::type>;
 //    typedef type_wrapper<LIST> > ListW;
     using ListW = type_wrapper<G4FastList<OBJECT>>;
 //    typedef type_wrapper<G4ManyFastLists<typename ObjectW::type> > ManyListsW;
     using ManyListsW = type_wrapper<G4ManyFastLists<OBJECT>>;
 //    typedef type_wrapper<G4ManyFastLists_iterator<typename ObjectW::type> > ManyListsIteratorW;
     using ManyListsIteratorW = type_wrapper<G4ManyFastLists_iterator<OBJECT>>;
 
 //#ifdef WIN32
 //    friend typename ListW::type;
 //    friend typename ManyListsW::type;
 //    friend typename ManyListsIteratorW::type;
 ////#elif defined(__clang__)
 ////    friend T;
 ////    friend G4ManyFastLists_iterator<OBJECT>;
 //#else
 //    friend class ListW::type;
 //    friend class ManyListsW::type;
 //    friend struct ManyListsIteratorW::type;
 //#endif
 
   public:
     ~G4FastListNode();
 
     OBJECT* GetObject()
     {
       return fpObject;
     }
 
     const OBJECT* GetObject() const
     {
       return fpObject;
     }
 
     G4FastListNode<OBJECT>* GetNext()
     {
       return fpNext;
     }
     const G4FastListNode<OBJECT>* GetNext() const
     {
       return fpNext;
     }
     G4FastListNode<OBJECT>* GetPrevious()
     {
       return fpPrevious;
     }
     const G4FastListNode<OBJECT>* GetPrevious() const
     {
       return fpPrevious;
     }
     bool IsAttached()
     {
       return fAttachedToList;
     }
 
   //protected:
     /** Default constructor */
     G4FastListNode(OBJECT* track = nullptr);
 
     void SetNext(G4FastListNode<OBJECT>* node)
     {
       fpNext = node;
     }
     void SetPrevious(G4FastListNode<OBJECT>* node)
     {
       fpPrevious = node;
     }
     void SetAttachedToList(bool flag)
     {
       fAttachedToList = flag;
     }
 
     void UnHook();
 
     void DetachYourSelf();
     
     bool fAttachedToList;
     G4shared_ptr<_ListRef<G4FastList<OBJECT> > > fListRef;
     OBJECT* fpObject;
     G4FastListNode<OBJECT>* fpPrevious;
     G4FastListNode<OBJECT>* fpNext;
   };
 
 /**
  * G4FastList is used by G4TrackHolder to save
  * G4IT tracks only. Its advantage lies to a fast
  * search of a track in this list.
  */
 
 template<class OBJECT>
   class G4FastList
   {
   protected:
     G4int fNbObjects;
 //    G4FastListNode<OBJECT> * fpStart;
 //    G4FastListNode<OBJECT> * fpFinish;
     G4shared_ptr<_ListRef<G4FastList<OBJECT> > > fListRef;
 
     G4FastListNode<OBJECT> fBoundary;
     // Must be empty and link to the last non-empty node of the list
     // and to the first non-empty node of the list (begin())
     // The iterator returned by end() is linked to this empty node
 
   public:
     class Watcher
     {
     public:
       enum Priority
       {
         eExtreme,
         eHigh,
         eNormal,
         eLow,
         eVeryLow
       };
 
       using list = G4FastList<OBJECT>;
 
       Watcher()
       {
         fPriority = Priority::eVeryLow;
       }
 
       virtual ~Watcher()
       {
         auto it = fWatching.begin();
         auto end = fWatching.end();
         for(;it!=end;it++)
         {
           (*it)->RemoveWatcher(this);
         }
       }
 
       virtual G4String GetWatcherName(){
         return "";
       }
 
       Priority GetPriority() const{
         return fPriority;
       }
 
       // ===============================
       // NOTIFICATIONS
       void NotifyDeletingList(G4FastList<OBJECT>*){;}
       // used by PriorityList & ManyFastLists
 
       virtual void NotifyAddObject(OBJECT*, G4FastList<OBJECT>*){;}
       virtual void NotifyRemoveObject(OBJECT*, G4FastList<OBJECT>*){;}
 //      void NotifyEmpty(OBJECT*, G4FastList<OBJECT>*){;}
 
       // ===============================
 
       void Watch(G4FastList<OBJECT>* fastList)
       {
         fWatching.insert(fastList);
         fastList->AddWatcher(this);
       }
 
       void StopWatching(G4FastList<OBJECT>* fastList, bool removeWatcher = true)
       {
         auto it = fWatching.find(fastList);
         if(it == fWatching.end()) return; //TODO: exception?
         fWatching.erase(it);
         if(removeWatcher) fastList->RemoveWatcher(this);
       }
 
     protected:
       Priority fPriority;
 
     private:
       std::set<G4FastList<OBJECT>*> fWatching;
     };
 
     template<typename WATCHER_TYPE>
     class TWatcher : public Watcher
     {
       public:
       TWatcher() : Watcher(){}
       virtual ~TWatcher()= default;
       virtual G4String GetWatcherName()
       {
         return typeid(WATCHER_TYPE).name();
       }
     };
 
   protected:
     using WatcherSet = std::set<typename G4FastList<OBJECT>::Watcher*,
                     sortWatcher<OBJECT>>;
     WatcherSet   fWatchers;
     G4FastListNode<G4FastList<OBJECT> >* fpNodeInManyLists;
 
   public:
     using object = OBJECT;
     using iterator = G4FastList_iterator<OBJECT>;
     using const_iterator = G4FastList_const_iterator<OBJECT>;
     using node = G4FastListNode<OBJECT>;
 
     G4FastList();
     ~G4FastList();
 
     void SetListNode(G4FastListNode<G4FastList<OBJECT> >* __node)
     {
       fpNodeInManyLists = __node;
     }
 
     G4FastListNode<G4FastList<OBJECT> >* GetListNode()
     {
       return fpNodeInManyLists;
     }
 
     void AddWatcher(Watcher* watcher)
     {
       fWatchers.insert(watcher);
     }
 
     void RemoveWatcher(Watcher* watcher)
     {
       auto it = fWatchers.find(watcher);
       if(it == fWatchers.end()) return; //TODO: exception?
       fWatchers.erase(it);
     }
 
     inline OBJECT* back()
     {
 //      if (fNbObjects != 0) return fpFinish->GetObject();
       if (fNbObjects != 0) return fBoundary.GetPrevious()->GetObject();
       return 0;
     }
 
     inline G4int size() const
     {
       return fNbObjects;
     }
 
     inline bool empty() const;
     iterator insert(iterator /*position*/, OBJECT*);
 
     inline iterator begin();
     inline const_iterator begin() const;
 
     inline iterator end();
     inline const_iterator end() const;
     /**
      * return an iterator that contains an empty node
      * use for boundary checking only
      */
 
     bool Holds(const OBJECT*) const;
 
     inline void push_front(OBJECT* __track);
     inline void push_back(OBJECT* __track);
     OBJECT* pop_back();
 
     void remove(OBJECT*);
 
     iterator pop(OBJECT*);
     iterator pop(G4FastListNode<OBJECT>*);
     iterator pop(iterator __first, iterator __last);
     iterator erase(OBJECT*);
     /**
      * Complexity = constant
      * By storing the node inside the object, we avoid
      * searching through all the container.
      */
 
     iterator erase(iterator __first, iterator __last);
     /**
      * Complexity = linear in size between __first and __last
      */
 
     void clear();
     void transferTo(G4FastList<OBJECT>*);
     /**
      * Complexity = constant
      */
 
     static G4FastListNode<OBJECT>* GetNode(OBJECT*);
     static void SetNode(OBJECT* __obj, G4FastListNode<OBJECT>* __node);
     static G4FastList<OBJECT>* GetList(OBJECT*);
     static G4FastList<OBJECT>* GetList(G4FastListNode<OBJECT>* __trackListNode);
     static void Pop(OBJECT*);
 
   protected:
     G4FastListNode<OBJECT>* CreateNode(OBJECT*);
     static G4FastListNode<OBJECT>* __GetNode(OBJECT*);
     G4FastListNode<OBJECT>* Flag(OBJECT*);
     G4FastListNode<OBJECT>* Unflag(OBJECT*);
     void Unflag(G4FastListNode<OBJECT>* __trackListNode);
     void CheckFlag(G4FastListNode<OBJECT>*);
     void DeleteObject(OBJECT*);
 
     void Hook(G4FastListNode<OBJECT>* /*position*/,
               G4FastListNode<OBJECT>* /*toHook*/);
     void Unhook(G4FastListNode<OBJECT>*);
     G4FastListNode<OBJECT>* EraseListNode(OBJECT*);
 
   private:
     G4FastList(const G4FastList<OBJECT>& other);
     G4FastList<OBJECT> & operator=(const G4FastList<OBJECT> &right);
     G4bool operator==(const G4FastList<OBJECT> &right) const;
     G4bool operator!=(const G4FastList<OBJECT> &right) const;
   };
 
 
 template<class OBJECT>
   struct sortWatcher
   {
     bool operator()(const typename G4FastList<OBJECT>::Watcher* left,
                     const typename G4FastList<OBJECT>::Watcher* right) const
     {
       if(left && right)
       {
         if(left->GetPriority() != right->GetPriority())
         {
           return left->GetPriority() < right->GetPriority();
         }
         return left < right;
       }
       return false;
     }
   };
 
 
 /**
  * G4FastList_iterator enables to go through
  * the tracks contained by a list.
  */
 
 template<typename OBJECT>
   struct G4FastList_iterator
   {
 //    friend class G4FastList<OBJECT>;
     using _Self = G4FastList_iterator<OBJECT>;
     using _Node = G4FastListNode<OBJECT>;
 
     G4FastList_iterator() = default;
 
     explicit G4FastList_iterator(_Node* __x) :
         fpNode(__x)
     {
     }
 
     G4FastList_iterator(const G4FastList_iterator& right) = default;
     _Self& operator=(const G4FastList_iterator& right) = default;
 
     _Node* GetNode()
     {
       return fpNode;
     }
 
     const _Node* GetNode() const
     {
       return fpNode;
     }
 
     OBJECT*
     operator*();
 
     const OBJECT*
     operator*() const;
 
     OBJECT*
     operator->();
 
     const OBJECT*
     operator->() const;
 
     _Self&
     operator++()
     {
       fpNode = fpNode->GetNext();
       return *this;
     }
 
     _Self operator++(int)
     {
       _Self __tmp = *this;
       fpNode = fpNode->GetNext();
       return __tmp;
     }
 
     _Self&
     operator--()
     {
       fpNode = fpNode->GetPrevious();
       return *this;
     }
 
     _Self operator--(int)
     {
       _Self __tmp = *this;
       fpNode = fpNode->GetPrevious();
       return __tmp;
     }
 
     G4bool operator==(const _Self& __x) const
     {
       return (fpNode == __x.fpNode);
     }
 
     G4bool operator!=(const _Self& __x) const
     {
       return (fpNode != __x.fpNode);
     }
 
 //  private:
     // The only member points to the G4FastList_iterator element.
     _Node* fpNode = nullptr;
   };
 
 /**
  * G4FastList_iterator enables to go through
  * the tracks contained by a list.
  */
 
 template<typename OBJECT>
   struct G4FastList_const_iterator
   {
 //    friend class G4FastList<OBJECT>;
     using _Self = G4FastList_const_iterator<OBJECT>;
     using _Node = G4FastListNode<OBJECT>;
 
     G4FastList_const_iterator() = default;
 
     explicit G4FastList_const_iterator(const _Node* __x) :
         fpNode(__x)
     {
     }
 
     G4FastList_const_iterator(const G4FastList_const_iterator& right) = default;
     _Self& operator=(const G4FastList_const_iterator& right) = default;
 
     G4FastList_const_iterator(const G4FastList_iterator<OBJECT>& right) :
         fpNode(right.GetNode())
     {
     }
 
     _Self& operator=(const G4FastList_iterator<OBJECT>& right)
     {
       fpNode = right.GetNode();
       return *this;
     }
 
     const OBJECT*
     operator*() const
     {
       if(fpNode == nullptr) return nullptr;
       return fpNode->GetObject();
     }
 
     const OBJECT*
     operator->() const
     {
       if(fpNode == 0) return 0;
       return fpNode->GetObject();
     }
 
     _Self&
     operator++()
     {
       fpNode = fpNode->GetNext();
       return *this;
     }
 
     _Self operator++(int)
     {
       _Self __tmp = *this;
       fpNode = fpNode->GetNext();
       return __tmp;
     }
 
     _Self&
     operator--()
     {
       fpNode = fpNode->GetPrevious();
       return *this;
     }
 
     _Self operator--(int)
     {
       _Self __tmp = *this;
       fpNode = fpNode->GetPrevious();
       return __tmp;
     }
 
     G4bool operator==(const _Self& __x) const
     {
       return (fpNode == __x.fpNode);
     }
 
     G4bool operator!=(const _Self& __x) const
     {
       return (fpNode != __x.fpNode);
     }
 
 //  private:
     // The only member points to the G4FastList_iterator element.
     const _Node* fpNode = nullptr;
   };
 
 #include "G4FastList.icc"

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