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

Warning, file /include/Geant4/G4ManyFastLists.hh was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 //
 // ********************************************************************
 // * 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.          *
 // ********************************************************************
 //
 /*
  * G4ManyFastLists.hh
  *
  *  Created on: 17 nov. 2014
  *      Author: kara
  */
 
 #pragma once
 
 #include "G4FastList.hh"
 #include <set>
 
 template<class OBJECT>
   struct G4ManyFastLists_iterator;
 
 /*
  * Roll over many list as if it was one
  */
 template<class OBJECT>
   class G4ManyFastLists : public G4FastList<OBJECT>::Watcher
   {
   protected:
     using ManyLists = G4FastList<G4FastList<OBJECT>>;
     ManyLists fAssociatedLists;
     // TODO use "marked list" insted of vector
 
     using WatcherSet = std::set<typename G4FastList<OBJECT>::Watcher*,
         sortWatcher<OBJECT>>;
     WatcherSet* fMainListWatchers;
 
   public:
     using iterator = G4ManyFastLists_iterator<OBJECT>;
 
     G4ManyFastLists() : G4FastList<OBJECT>::Watcher(),
         fAssociatedLists(), fMainListWatchers(nullptr)
     {
     }
 
     ~G4ManyFastLists() override = default;
 
     virtual void NotifyDeletingList(G4FastList<OBJECT>* __list)
     {
       fAssociatedLists.pop(__list);
     }
 
     void AddGlobalWatcher(typename G4FastList<OBJECT>::Watcher* watcher)
     {
       if(fMainListWatchers == nullptr)
       {
         fMainListWatchers = new WatcherSet();
       }
 
       fMainListWatchers->insert(watcher);
 
       typename ManyLists::iterator it = fAssociatedLists.begin();
       typename ManyLists::iterator _end = fAssociatedLists.end();
 
       for(;it != _end ;++it)
       {
         watcher->Watch(*it);
 //        (*it)->AddWatcher(watcher);
 //        (*it)->AddWatcher(watcher);
       }
     }
 
     inline void Add(G4FastList<OBJECT>* __list)
     {
       if (__list == nullptr) return;
       fAssociatedLists.push_back(__list); // TODO use the table doubling tech
       //__list->AddWatcher(this);
       this->Watch(__list);
 
       if(fMainListWatchers == nullptr) return;
 
       auto it_watcher = fMainListWatchers->begin();
       auto end_watcher = fMainListWatchers->end();
 
 //      G4cout << "G4ManyFastLists::Add -- N watchers ="
 //             << fMainListWatchers->size()
 //             << G4endl;
 
       for(;it_watcher != end_watcher ;++it_watcher)
       {
 //        G4cout << " *** *** *** WATCH --- "
 //                           << (*it_watcher)->GetWatcherName()
 //                           << G4endl;
         (*it_watcher)->Watch(__list);
       }
 
       if(__list->empty() == false)
       {
         it_watcher = fMainListWatchers->begin();
 
         for(;it_watcher != end_watcher ;++it_watcher)
         {
           typename G4FastList<OBJECT>::iterator it_obj = __list->begin();
           for(;it_obj != __list->end() ;++it_obj)
           {
 //            G4cout << " *** *** *** NOTIFY ADD OBJ --- "
 //                   << (*it_watcher)->GetWatcherName()
 //                   << G4endl;
 
             (*it_watcher)->NotifyAddObject(*it_obj,__list);
           }
         }
       }
 //      else
 //      {
 //        G4cout << "__list->empty() == true" << G4endl;
 //      }
 
       /*
       typename ManyLists::const_iterator __it = fAssociatedLists
           .begin();
       typename ManyLists::const_iterator __end = fAssociatedLists
           .end();
       for (; __it != __end; __it++)
       {
         assert(*__it);
       }
       */
     }
 
     inline void Remove(G4FastList<OBJECT>* __list)
     {
       if (__list == nullptr) return;
       fAssociatedLists.pop(__list); // TODO use the table doubling tech
       __list->RemoveWatcher(this);
       this->StopWatching(__list);
 
       auto it = fMainListWatchers->begin();
       auto _end = fMainListWatchers->end();
 
       for(;it != _end ;++it)
       {
         (*it)->StopWatching(__list);
       }
 
 //      typename ManyLists::node* __node = __list->GetListNode();
 //      if(__node)
 //      {
 //        __list->SetListNode(0);
 //        delete __node;
 //      }
     }
 
     inline bool Holds(OBJECT* __track) const
     {
       typename ManyLists::const_iterator __it = fAssociatedLists.begin();
       typename ManyLists::const_iterator __end = fAssociatedLists.end();
       for (; __it != __end; __it++)
         if ((*__it)->Holds(__track)) return true;
       return false;
     }
 
     inline size_t size() const
     {
       size_t __size(0);
       for (auto __it : fAssociatedLists)
       {
         __size += __it->size();
       }
       return __size;
     }
 
     inline void RemoveLists()
     {
       typename ManyLists::iterator __it = fAssociatedLists.begin();
       typename ManyLists::iterator __end = fAssociatedLists.end();
       for (; __it != __end; __it++)
       {
         if (*__it)
         {
           (*__it)->clear();
           typename ManyLists::iterator next = __it;
           next++;
           Remove(*__it);
           typename ManyLists::node* __node = __it.GetNode();
           if(__node)
           {
             __node->GetObject()->SetListNode(nullptr);
             delete __node;
           }
 //          delete (*__it);
 
           __it = next;
         }
       }
       fAssociatedLists.clear();
     }
 
     inline void ClearLists()
     {
       typename ManyLists::iterator __it = fAssociatedLists.begin();
       typename ManyLists::iterator __end = fAssociatedLists.end();
       for (; __it != __end; __it++)
         if (*__it) (*__it)->clear();
     }
 
     inline iterator begin();
     inline iterator end();
 
     void pop(OBJECT*);
   };
 
 template<class OBJECT>
   struct G4ManyFastLists_iterator
   {
     using ManyLists = G4FastList<G4FastList<OBJECT>>;
 
     using _Self = G4ManyFastLists_iterator;
     using _Node = G4FastListNode<OBJECT>;
 
     G4FastList_iterator<OBJECT> fIterator;
     typename ManyLists::iterator fCurrentListIt;
     ManyLists* fLists;
 
   private:
     G4ManyFastLists_iterator() = default;
 
   public:
     explicit G4ManyFastLists_iterator(G4FastList_iterator<OBJECT> __x,
                                       typename ManyLists::iterator __it,
                                       ManyLists* __lists) :
         fIterator(__x), fCurrentListIt(__it), fLists(__lists)
     {
     }
 
     G4ManyFastLists_iterator(const G4ManyFastLists_iterator& __x) = default;
     _Self& operator=(const G4ManyFastLists_iterator& __x) = default;
 
     _Node* GetNode()
     {
       return fIterator.GetNode();
     }
 
     G4FastList<OBJECT>* GetTrackList()
     {
       return *fCurrentListIt;
     }
 
     OBJECT* operator*()
     {
       return *fIterator;
     }
     const OBJECT* operator*() const
     {
       return *fIterator;
     }
     OBJECT* operator->()
     {
       return *fIterator;
     }
     const OBJECT* operator->() const
     {
       return *fIterator;
     }
 
     _Self UpdateToNextValidList();
     _Self& operator++();
 
     _Self operator++(int)
     {
       return operator++();
     }
 
     _Self&
     operator--()
     {
       if (fLists->empty())
       {
         fIterator = G4FastList_iterator<OBJECT>();
         return *this;
       }
       if (fCurrentListIt == fLists->begin())
       {
         if (fIterator == (*fCurrentListIt)->begin())
         {
           fIterator = G4FastList_iterator<OBJECT>();
           return *this;
         }
       }
 
       if (fCurrentListIt == fLists->end())
       {
         fCurrentListIt--;
         fIterator = (*fCurrentListIt)->end();
       }
       else if (fIterator == (*fCurrentListIt)->begin())
       {
         fCurrentListIt--;
         fIterator = (*fCurrentListIt)->end();
       }
 
       fIterator--;
 
       while (((*fCurrentListIt)->empty() || fIterator.GetNode() == nullptr
               || fIterator.GetNode()->GetObject() == nullptr)
              && fCurrentListIt != fLists->begin())
       {
         fIterator = (*fCurrentListIt)->begin();
         fCurrentListIt--;
         fIterator = (*fCurrentListIt)->end();
         fIterator--;
       }
 
       if (fIterator.GetNode() == nullptr && fCurrentListIt == fLists->begin())
       {
         fIterator = G4FastList_iterator<OBJECT>();
         return *this;
       }
 
       return *this;
     }
 
     _Self operator--(int)
     {
       return operator--();
     }
 
     G4bool operator==(const _Self& __x) const
     {
       return (fIterator == __x.fIterator && fCurrentListIt == __x.fCurrentListIt);
     } // Fast check
 
     G4bool operator!=(const _Self& __x) const
     {
       return !(this->operator ==(__x));
     }
 
   protected:
     void HasReachedEnd()
     {
       if (fLists->empty() == false)
       {
         fIterator = (*(fLists->end()--))->end();
       }
       else
       {
         fIterator = G4FastList_iterator<OBJECT>();
       }
     }
   };
 
 template<class OBJECT>
   typename G4ManyFastLists<OBJECT>::iterator G4ManyFastLists<OBJECT>::begin()
   {
     if (fAssociatedLists.empty())
     {
       return G4ManyFastLists_iterator<OBJECT>(G4FastList_iterator<OBJECT>(),
                                              fAssociatedLists.end(),
                                              &fAssociatedLists);
     }
 
     typename G4FastList<OBJECT>::iterator trackList_it;
     int i = 0;
 
     typename ManyLists::iterator it = fAssociatedLists.begin();
     typename ManyLists::iterator _end = fAssociatedLists.end();
 
     while (it != _end)
     {
       if (*it && (*it)->empty() == false)
       {
         trackList_it = (*it)->begin();
         break;
       }
       i++;
       it++;
     };
 
     if (i == fAssociatedLists.size() || it == _end)
     {
       return end();
     }
 
     return G4ManyFastLists_iterator<OBJECT>(trackList_it,
 //                                           fAssociatedLists.begin(),
                                             it,
                                            &fAssociatedLists);
   }
 
 template<class OBJECT>
 typename G4ManyFastLists<OBJECT>::iterator G4ManyFastLists<OBJECT>::end()
   {
     if (fAssociatedLists.empty())
     {
       return G4ManyFastLists_iterator<OBJECT>(G4FastList_iterator<OBJECT>(),
                                              fAssociatedLists.end(),
                                              &fAssociatedLists);
     }
 
     return G4ManyFastLists_iterator<OBJECT>((fAssociatedLists.end()--)->end(),
                                            fAssociatedLists.end(),
                                            &fAssociatedLists);
   }
 
 #include "G4ManyFastLists.icc"

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