EIC code displayed by LXR master/​include/​Geant4/​G4FastList.icc	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 (kara (AT) cenbg . in2p3 . fr)
 //
 // History:
 // -----------
 // 10 Oct 2011 M.Karamitros created
 //
 // -------------------------------------------------------------------
 
 //#ifndef G4FASTLIST_ICC_
 //#define G4FASTLIST_ICC_
 
 //***********************************************************
 // TrackList_iterator
 template<class OBJECT>
   OBJECT*
   G4FastList_iterator<OBJECT>::operator*()
   {
     if (fpNode == nullptr) return nullptr;
     return fpNode->GetObject();
   }
 
 template<class OBJECT>
   OBJECT*
   G4FastList_iterator<OBJECT>::operator->()
   {
     if (fpNode == nullptr) return nullptr;
     return fpNode->GetObject();
   }
 
 template<class OBJECT>
   const OBJECT*
   G4FastList_iterator<OBJECT>::operator*() const
   {
     if (fpNode == 0) return 0;
     return fpNode->GetObject();
   }
 
 template<class OBJECT>
   const OBJECT*
   G4FastList_iterator<OBJECT>::operator->() const
   {
     if (fpNode == 0) return 0;
     return fpNode->GetObject();
   }
 
 //***********************************************************
 // TrackNodeList
 
 template<class OBJECT>
   G4FastListNode<OBJECT>::G4FastListNode(OBJECT* track) :
       fpObject(track), fpPrevious(nullptr), fpNext(nullptr)
   {
     fAttachedToList = false;
   }
 
 template<class OBJECT>
   G4FastListNode<OBJECT>::~G4FastListNode()
   {
     if (fListRef && fListRef->fpList)
     {
       fListRef->fpList->pop(this);
     }
   }
 
 template<class OBJECT>
   void G4FastListNode<OBJECT>::DetachYourSelf()
   {
     if(fpObject)
     {
       fpObject->SetListNode(nullptr);
     }
   }
 
 //***********************************************************
 
 template<class OBJECT>
   G4FastList<OBJECT>::G4FastList() :
       fBoundary()
   {
     fListRef.reset(new _ListRef<G4FastList<OBJECT> >(this));
     fNbObjects = 0;
     fBoundary.SetPrevious(&fBoundary);
     fBoundary.SetNext(&fBoundary);
     fBoundary.fAttachedToList = true;
     fpNodeInManyLists = nullptr;
   }
 
 // should not be used
 template<class OBJECT>
   G4FastList<OBJECT>::G4FastList(const G4FastList<OBJECT>& /*other*/) :
       fBoundary()
   {
     // One track should not belong to two different trackLists
     fNbObjects = 0;
     fpNodeInManyLists = 0;
   }
 
 template<class OBJECT>
   G4FastList<OBJECT>& G4FastList<OBJECT>::operator=(const G4FastList<OBJECT>& other)
   {
     // One track should not belong to two different trackList
     if (this == &other) return *this; // handle self assignment
     //assignment operator
     return *this;
   }
 
 template<class OBJECT>
   G4FastList<OBJECT>::~G4FastList()
   {
     if (fNbObjects != 0)
     {
       G4FastListNode<OBJECT> * __stackedTrack = fBoundary.GetNext();
       G4FastListNode<OBJECT> * __nextStackedTrack;
 
       // delete tracks in the stack
       while (__stackedTrack && __stackedTrack != &(fBoundary))
       {
         __nextStackedTrack = __stackedTrack->GetNext();
         OBJECT* __obj = __stackedTrack->GetObject();
 
         delete __stackedTrack;
         __stackedTrack = nullptr;
 
         if (__obj)
         {
           //////////////
           DeleteObject(__obj);
           __obj = nullptr;
           //////////////
         }
         __stackedTrack = __nextStackedTrack;
       }
     }
     fNbObjects = 0;
 
     auto it = fWatchers.begin();
     auto _end = fWatchers.end();
 
     for (; it != _end; it++)
     {
       (*it)->NotifyDeletingList(this);
       (*it)->StopWatching(this, false);
     }
 
     if (fpNodeInManyLists)
     {
       delete fpNodeInManyLists;
       fpNodeInManyLists = nullptr;
     }
   }
 
 template<class OBJECT>
   bool G4FastList<OBJECT>::empty() const
   {
     return (fNbObjects == 0);
   }
 
 template<class OBJECT>
   typename G4FastList<OBJECT>::iterator G4FastList<OBJECT>::begin()
   {
     return iterator(fBoundary.GetNext());
   }
 
 template<class OBJECT>
   typename G4FastList<OBJECT>::const_iterator G4FastList<OBJECT>::begin() const
   {
     return const_iterator(fBoundary.GetNext());
   }
 
 template<class OBJECT>
   typename G4FastList<OBJECT>::iterator G4FastList<OBJECT>::end()
   {
     return iterator(&(fBoundary));
   }
 
 template<class OBJECT>
   typename G4FastList<OBJECT>::const_iterator G4FastList<OBJECT>::end() const
   {
     return const_iterator(&(fBoundary));
   }
 // return an iterator that contains an empty node
 // use for boundary checking only
 
 template<class OBJECT>
   void G4FastList<OBJECT>::push_front(OBJECT* __obj)
   {
     insert(begin(), __obj);
   }
 
 template<class OBJECT>
   void G4FastList<OBJECT>::push_back(OBJECT* __obj)
   {
     insert(end(), __obj);
   }
 
 template<class OBJECT>
   bool G4FastList<OBJECT>::Holds(const OBJECT* __obj) const
   {
     node* __node = GetNode(__obj);
     if(__node == 0) return false;
     return (__node->fListRef->fpList == this);
   }
 
 // TODO: A revoir
 template<class OBJECT>
   G4FastListNode<OBJECT>* G4FastList<OBJECT>::Flag(OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __node = GetNode(__obj);
 
     if (__node != nullptr)
     {
       // Suggestion move the node to this list
       if (__node->fAttachedToList)
       {
         G4ExceptionDescription exceptionDescription;
         exceptionDescription << "An object";
         exceptionDescription << " is already attached to a TrackList ";
         G4Exception("G4FastList<OBJECT>::Flag", "G4FastList001",
                     FatalErrorInArgument, exceptionDescription);
       }
     }
     else
     {
       __node = new G4FastListNode<OBJECT>(__obj);
       SetNode(__obj,__node);
     }
 
     __node->fAttachedToList = true;
     __node->fListRef = fListRef;
     return __node;
   }
 
 template<class OBJECT>
   G4FastListNode<OBJECT>* G4FastList<OBJECT>::CreateNode(OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __listNode = Flag(__obj);
     return __listNode;
   }
 
 template<class OBJECT>
   void G4FastList<OBJECT>::Hook(G4FastListNode<OBJECT>* __position,
                                 G4FastListNode<OBJECT>* __toHook)
   {
     /*
      __toHook->SetNext(__position);
      __toHook->SetPrevious(__position->GetPrevious());
      __position->GetPrevious()->SetNext(__toHook);
      __position->SetPrevious(__toHook);
      */
     G4FastListNode<OBJECT>* __previous = __position->GetPrevious();
     __toHook->SetPrevious(__previous);
     __toHook->SetNext(__position);
     __position->SetPrevious(__toHook);
     __previous->SetNext(__toHook);
 
     /*
      if (fNbObjects == 0)
      {
      // DEBUG
      //        G4cout << "fNbObjects == 0" << G4endl;
      fpStart = __toHook;
      fpFinish = __toHook;
      __toHook->SetNext(&fBoundary);
      __toHook->SetPrevious(&fBoundary);
      //fBoundary.SetNext(__toHook);
      fBoundary.SetPrevious(__toHook);
      } else if (__position == &fBoundary)
      {
      // DEBUG
      //        G4cout << "__position == &fBoundary" << G4endl;
      fpFinish->SetNext(__toHook);
      __toHook->SetPrevious(fpFinish);
 
      __toHook->SetNext(&fBoundary);
      fBoundary.SetPrevious(__toHook);
 
      fpFinish = __toHook;
      } else if (__position == fpStart)
      {
      // DEBUG
      //        G4cout << "__position == fStart" << G4endl;
      __toHook->SetPrevious(&fBoundary);
      //fBoundary.SetNext(__toHook);
      __toHook->SetNext(fpStart);
      fpStart->SetPrevious(__toHook);
      fpStart = __toHook;
      } else
      {
      // DEBUG
      //        G4cout << "else" << G4endl;
      G4FastListNode<OBJECT>* __previous = __position->GetPrevious();
      __toHook->SetPrevious(__previous);
      __toHook->SetNext(__position);
      __position->SetPrevious(__toHook);
      __previous->SetNext(__toHook);
      }
      */
     fNbObjects++;
 
     if(fWatchers.empty() == false)
     {
       auto it = fWatchers.begin();
       auto _end = fWatchers.end();
 
       for (; it != _end; it++)
       {
         (*it)->NotifyAddObject(__toHook->GetObject(), this);
       }
     }
   }
 
 template<class OBJECT>
   void G4FastListNode<OBJECT>::UnHook()
   {
     G4FastListNode<OBJECT>* __next_node = this->fpNext;
     G4FastListNode<OBJECT>* __prev_node = this->fpPrevious;
 
     if (__prev_node)
     {
       __prev_node->fpNext = __next_node;
     }
 
     if (__next_node)
     {
       __next_node->fpPrevious = __prev_node;
     }
     fpNext = nullptr;
     fpPrevious = nullptr;
   }
 
 template<class OBJECT>
   void G4FastList<OBJECT>::Unhook(G4FastListNode<OBJECT>* __toUnHook)
   {
     __toUnHook->UnHook();
 
     fNbObjects--;
 
     auto it = fWatchers.begin();
     auto _end = fWatchers.end();
 
     for (; it != _end; it++)
     {
       (*it)->NotifyRemoveObject(__toUnHook->GetObject(), this);
     }
   }
 
 template<class OBJECT>
   typename G4FastList<OBJECT>::iterator
   G4FastList<OBJECT>::insert(typename G4FastList<OBJECT>::iterator __position,
                              OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __node = CreateNode(__obj);
     Hook(__position.fpNode, __node);
     return iterator(__node);
   }
 
 //____________________________________________________________________
 //
 //                      WITHDRAW FROM LIST
 //____________________________________________________________________
 
 template<class OBJECT>
   void G4FastList<OBJECT>::CheckFlag(G4FastListNode<OBJECT>* __node)
   {
     if (__node->fListRef->fpList != this)
     {
       G4ExceptionDescription exceptionDescription;
       exceptionDescription << "The object "
       << " is not correctly linked to a G4FastList." << G4endl
       << "You are probably trying to withdraw this object "
       << "from the list but it probably does not belong to "
       << "this fast list." << G4endl;
       G4Exception("G4FastList<OBJECT>::CheckFlag", "G4FastList002",
                   FatalErrorInArgument, exceptionDescription);
     }
   }
 
 template<class OBJECT>
   G4FastListNode<OBJECT>* G4FastList<OBJECT>::Unflag(OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __node = __GetNode(__obj);
     CheckFlag(__node);
     __node->fAttachedToList = false;
     __node->fListRef.reset();
     return __node;
   }
 
 template<class OBJECT>
   void G4FastList<OBJECT>::Unflag(G4FastListNode<OBJECT>* __node)
   {
     CheckFlag(__node);
     __node->fAttachedToList = false;
     __node->fListRef.reset();
     return;
   }
 
 template<class OBJECT>
   OBJECT* G4FastList<OBJECT>::pop_back()
   {
     if (fNbObjects == 0) return 0;
     G4FastListNode<OBJECT> * __aNode = fBoundary.GetPrevious();
     Unhook(__aNode);
     Unflag(__aNode);
     return __aNode->GetObject();
   }
 
 template<class OBJECT>
   typename G4FastList<OBJECT>::iterator G4FastList<OBJECT>::pop(OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __node = Unflag(__obj);
     iterator __next(__node->GetNext());
     Unhook(__node);
     return __next;
   }
 
 template<class OBJECT>
   typename G4FastList<OBJECT>::iterator
   G4FastList<OBJECT>::pop(G4FastListNode<OBJECT>* __node)
   {
     Unflag(__node);
     iterator __next(__node->GetNext());
     Unhook(__node);
     return __next;
   }
 
 template<class OBJECT>
   typename G4FastList<OBJECT>::iterator G4FastList<OBJECT>::erase(OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __next_node = EraseListNode(__obj);
     //////////////////
     DeleteObject(__obj);
     __obj = nullptr;
     //////////////////
     iterator __next(__next_node);
     return __next;
   }
 
 template<class OBJECT>
   G4FastListNode<OBJECT>* G4FastList<OBJECT>::EraseListNode(OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __node = Unflag(__obj);
     __node->DetachYourSelf();
     G4FastListNode<OBJECT>* __next = __node->GetNext();
     Unhook(__node);
     delete __node;
     return __next;
   }
 
 template<class OBJECT>
   void G4FastList<OBJECT>::DeleteObject(OBJECT*)
   {
 //    delete __obj;
   }
 
 template<class OBJECT>
   void G4FastList<OBJECT>::remove(OBJECT* __obj)
   {
     this->erase(__obj);
   }
 
 template<class OBJECT>
   typename G4FastList<OBJECT>::iterator G4FastList<OBJECT>::pop(iterator __first,
                                                                 iterator __last)
   {
     if (fNbObjects == 0) return iterator(&fBoundary);
 
     while (__first != __last)
     {
       if (__first.fpNode) __first = pop(*__first);
     }
     return __last;
   }
 
 template<class OBJECT>
   typename G4FastList<OBJECT>::iterator G4FastList<OBJECT>::erase(iterator __first,
                                                                   iterator __last)
   {
     if (fNbObjects == 0) return iterator(&fBoundary);
 
     while (__first != __last)
     {
       if (__first.fpNode) __first = erase(*__first);
     }
     return __last;
   }
 
 template<class OBJECT>
   void G4FastList<OBJECT>::clear()
   {
     erase(begin(), end());
   }
 
 template<class OBJECT>
   void G4FastList<OBJECT>::transferTo(G4FastList<OBJECT>* __destination)
   {
     if (fNbObjects == 0) return;
 
     if (__destination->fNbObjects == 0)
     {
 
       if(__destination->fWatchers.empty()==false)
       {
         auto it = __destination->fWatchers.begin();
         auto _end = __destination->fWatchers.end();
 
 //        G4cout << "G4FastList<OBJECT>::transferTo --- Watcher size = "
 //               << __destination->fWatchers.size()
 //               << G4endl;
 
         for (; it != _end; it++)
         {
           for(iterator it2 = this->begin() ;
               it2 != this->end(); ++it2
           )
           {
             (*it)->NotifyAddObject(*it2, this);
           }
         }
       }
 
       __destination->fNbObjects = this->fNbObjects;
 
       __destination->fBoundary.SetNext(fBoundary.GetNext());
       __destination->fBoundary.SetPrevious(fBoundary.GetPrevious());
       fBoundary.GetNext()->SetPrevious(&__destination->fBoundary);
       fBoundary.GetPrevious()->SetNext(&__destination->fBoundary);
     }
     else
     {
       if(__destination->fWatchers.empty()==false)
       {
         auto it = __destination->fWatchers.begin();
         auto _end = __destination->fWatchers.end();
 
         for (; it != _end; it++)
         {
           for(iterator it2 = this->begin() ;
               it2 != this->end(); ++it2)
           {
             (*it)->NotifyAddObject(*it2, this);
           }
         }
       }
 
       node* lastNode = __destination->fBoundary.GetPrevious();
       lastNode->SetNext(fBoundary.GetNext());
       fBoundary.GetNext()->SetPrevious(lastNode);
       __destination->fBoundary.SetPrevious(fBoundary.GetPrevious());
       fBoundary.GetPrevious()->SetNext(&__destination->fBoundary);
 
       __destination->fNbObjects += this->fNbObjects;
     }
 
     fNbObjects = 0;
     this->fBoundary.SetPrevious(&this->fBoundary);
     this->fBoundary.SetNext(&this->fBoundary);
 
     fListRef->fpList = __destination;
   }
 
 //____________________________________________________________
 //
 //                      G4FastList<OBJECT> Utils
 //____________________________________________________________
 
 template<class OBJECT>
   G4FastListNode<OBJECT>* G4FastList<OBJECT>::__GetNode(OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __node = GetNode(__obj);
     // TODO : complete the exception
     if (__node == nullptr)
     {
       G4ExceptionDescription exceptionDescription;
       exceptionDescription << "The object ";
       exceptionDescription << " was not connected to any trackList ";
       G4Exception("G4FastList<OBJECT>::Unflag", "G4FastList003",
                   FatalErrorInArgument, exceptionDescription);
       return nullptr;
     }
     return __node;
   }
 
 template<class OBJECT>
   G4FastListNode<OBJECT>* G4FastList<OBJECT>::GetNode(OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __node = __obj->GetListNode();
     return __node;
   }
 
 template<class OBJECT>
   void G4FastList<OBJECT>::SetNode(OBJECT* __obj,
                                    G4FastListNode<OBJECT>* __node)
   {
     __obj->SetListNode(__node);
   }
 
 template<class OBJECT>
   G4FastList<OBJECT>* G4FastList<OBJECT>::GetList(OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __node = GetNode(__obj);
 
     if (__node == 0) return 0;
     if (__node->fListRef == nullptr) return 0;
 
     return __node->fListRef->fpTrackList;
   }
 
 template<class OBJECT>
   G4FastList<OBJECT>*
   G4FastList<OBJECT>::GetList(G4FastListNode<OBJECT>* __node)
   {
     if (__node == nullptr) return nullptr;
     if (__node->fListRef == nullptr) return nullptr;
 
     return __node->fListRef->fpList;
   }
 
 template<class OBJECT>
   void G4FastList<OBJECT>::Pop(OBJECT* __obj)
   {
     G4FastListNode<OBJECT>* __node = G4FastList<OBJECT>::GetNode(__obj);
     G4FastList<OBJECT>* __list = G4FastList<OBJECT>::GetList(__node);
     if (__list) __list->pop(__node);
   }
 
 //#endif /* G4FASTLIST_ICC_*/

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