G4ManyFastLists< OBJECT > Class Template Reference

#include <G4ManyFastLists.hh>

Inheritance diagram for G4ManyFastLists< OBJECT >:

Public Types
using	iterator = G4ManyFastLists_iterator<OBJECT>
Public Types inherited from G4FastList< OBJECT >::Watcher
enum	Priority {   eExtreme , eHigh , eNormal , eLow ,   eVeryLow }
using	list = G4FastList<OBJECT>

Public Member Functions
	G4ManyFastLists ()
	~G4ManyFastLists () override=default
virtual void	NotifyDeletingList (G4FastList< OBJECT > *__list)
void	AddGlobalWatcher (typename G4FastList< OBJECT >::Watcher *watcher)
void	Add (G4FastList< OBJECT > *__list)
void	Remove (G4FastList< OBJECT > *__list)
bool	Holds (OBJECT *__track) const
size_t	size () const
void	RemoveLists ()
void	ClearLists ()
iterator	begin ()
iterator	end ()
void	pop (OBJECT *)
Public Member Functions inherited from G4FastList< OBJECT >::Watcher
	Watcher ()
virtual	~Watcher ()
virtual G4String	GetWatcherName ()
Priority	GetPriority () const
void	NotifyDeletingList (G4FastList< OBJECT > *)
virtual void	NotifyAddObject (OBJECT *, G4FastList< OBJECT > *)
virtual void	NotifyRemoveObject (OBJECT *, G4FastList< OBJECT > *)
void	Watch (G4FastList< OBJECT > *fastList)
void	StopWatching (G4FastList< OBJECT > *fastList, bool removeWatcher=true)

Protected Types
using	ManyLists = G4FastList<G4FastList<OBJECT>>
using	WatcherSet

Protected Attributes
ManyLists	fAssociatedLists
WatcherSet *	fMainListWatchers
Protected Attributes inherited from G4FastList< OBJECT >::Watcher
Priority	fPriority

Detailed Description

template<class OBJECT>
class G4ManyFastLists< OBJECT >

Definition at line 45 of file G4ManyFastLists.hh.

Member Typedef Documentation

iterator

template<class OBJECT>

using G4ManyFastLists< OBJECT >::iterator = G4ManyFastLists_iterator<OBJECT>

Definition at line 57 of file G4ManyFastLists.hh.

ManyLists

template<class OBJECT>

using G4ManyFastLists< OBJECT >::ManyLists = G4FastList<G4FastList<OBJECT>>

protected

Definition at line 48 of file G4ManyFastLists.hh.

WatcherSet

template<class OBJECT>

using G4ManyFastLists< OBJECT >::WatcherSet

protected

Initial value:

 std::set<typename G4FastList<OBJECT>::Watcher*,
        sortWatcher<OBJECT>>

Definition at line 52 of file G4ManyFastLists.hh.

Constructor & Destructor Documentation

G4ManyFastLists()

template<class OBJECT>

G4ManyFastLists< OBJECT >::G4ManyFastLists ( )

inline

Definition at line 59 of file G4ManyFastLists.hh.

                      : G4FastList<OBJECT>::Watcher(),
        fAssociatedLists(), fMainListWatchers(nullptr)
    {
    }

~G4ManyFastLists()

template<class OBJECT>

G4ManyFastLists< OBJECT >::~G4ManyFastLists ( )

overridedefault

Member Function Documentation

Add()

template<class OBJECT>

void G4ManyFastLists< OBJECT >::Add ( G4FastList< OBJECT > * __list )

inline

Definition at line 91 of file G4ManyFastLists.hh.

    {
      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);
      }
      */
    }

Referenced by PriorityList::NewMainList(), and PriorityList::PushToListOfSecondaries().

AddGlobalWatcher()

template<class OBJECT>

void G4ManyFastLists< OBJECT >::AddGlobalWatcher ( typename G4FastList< OBJECT >::Watcher * watcher )

inline

Definition at line 71 of file G4ManyFastLists.hh.

    {
      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);
      }
    }

begin()

template<class OBJECT>

G4ManyFastLists< OBJECT >::iterator G4ManyFastLists< OBJECT >::begin ( )

inline

Definition at line 371 of file G4ManyFastLists.hh.

  {
    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);
  }

Referenced by G4ITStepProcessor::ComputeInteractionLength(), and G4Scheduler::EndTracking().

ClearLists()

template<class OBJECT>

void G4ManyFastLists< OBJECT >::ClearLists ( )

inline

Definition at line 217 of file G4ManyFastLists.hh.

    {
      typename ManyLists::iterator __it = fAssociatedLists.begin();
      typename ManyLists::iterator __end = fAssociatedLists.end();
      for (; __it != __end; __it++)
        if (*__it) (*__it)->clear();
    }

end()

template<class OBJECT>

G4ManyFastLists< OBJECT >::iterator G4ManyFastLists< OBJECT >::end ( )

inline

Definition at line 409 of file G4ManyFastLists.hh.

  {
    if (fAssociatedLists.empty())
    {
      return G4ManyFastLists_iterator<OBJECT>(G4FastList_iterator<OBJECT>(),
                                             fAssociatedLists.end(),
                                             &fAssociatedLists);
    }
 
    return G4ManyFastLists_iterator<OBJECT>((fAssociatedLists.end()--)->end(),
                                           fAssociatedLists.end(),
                                           &fAssociatedLists);
  }

Referenced by begin(), G4ITStepProcessor::ComputeInteractionLength(), G4ITStepProcessor::DoIt(), and G4Scheduler::EndTracking().

Holds()

template<class OBJECT>

bool G4ManyFastLists< OBJECT >::Holds ( OBJECT * __track ) const

inline

Definition at line 172 of file G4ManyFastLists.hh.

    {
      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;
    }

NotifyDeletingList()

template<class OBJECT>

virtual void G4ManyFastLists< OBJECT >::NotifyDeletingList ( G4FastList< OBJECT > * __list )

inlinevirtual

Definition at line 66 of file G4ManyFastLists.hh.

    {
      fAssociatedLists.pop(__list);
    }

pop()

template<class OBJECT>

void G4ManyFastLists< OBJECT >::pop

(

OBJECT *

)

Remove()

template<class OBJECT>

void G4ManyFastLists< OBJECT >::Remove ( G4FastList< OBJECT > * __list )

inline

Definition at line 149 of file G4ManyFastLists.hh.

    {
      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;
//      }
    }

Referenced by G4ManyFastLists< G4Track >::RemoveLists().

RemoveLists()

template<class OBJECT>

void G4ManyFastLists< OBJECT >::RemoveLists ( )

inline

Definition at line 191 of file G4ManyFastLists.hh.

    {
      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();
    }

size()

template<class OBJECT>

size_t G4ManyFastLists< OBJECT >::size ( ) const

inline

Definition at line 181 of file G4ManyFastLists.hh.

    {
      size_t __size(0);
      for (auto __it : fAssociatedLists)
      {
        __size += __it->size();
      }
      return __size;
    }

Referenced by G4ITStepProcessor::DoIt().

Member Data Documentation

fAssociatedLists

template<class OBJECT>

ManyLists G4ManyFastLists< OBJECT >::fAssociatedLists

protected

Definition at line 49 of file G4ManyFastLists.hh.

Referenced by begin(), and end().

fMainListWatchers

template<class OBJECT>

WatcherSet* G4ManyFastLists< OBJECT >::fMainListWatchers

protected

Definition at line 54 of file G4ManyFastLists.hh.

---

The documentation for this class was generated from the following files:

• G4FastList.hh
• G4ManyFastLists.hh