Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Member Functions | List of all members
G4VTHitsVector< T, Vector_t > Class Template Reference

#include <G4THitsVector.hh>

+ Inheritance diagram for G4VTHitsVector< T, Vector_t >:

Public Types

typedef G4VTHitsVector< T, Vector_t > this_type
 
typedef T value_type
 
typedef Vector_t vector_type
 
typedef vector_type::iterator iterator
 
typedef vector_type::const_iterator const_iterator
 
typedef Vector_t::value_type store_type
 
typedef std::pair< G4int, store_type > pair_t
 
typedef std::map< G4int, store_type > map_t
 
typedef std::unordered_map< G4int, store_type > uomap_t
 
typedef std::multimap< G4int, store_type > mmap_t
 
typedef std::unordered_multimap< G4int, store_type > uommap_t
 

Public Member Functions

 G4VTHitsVector (G4int init_size=0)
 
 G4VTHitsVector (G4String detName, G4String colNam, G4int init_size=0)
 
virtual ~G4VTHitsVector ()
 
G4bool operator== (const this_type &rhs) const
 
virtual void DrawAllHits ()
 
virtual void PrintAllHits ()
 
Vector_t * GetContainer () const
 
Vector_t::size_type size ()
 
Vector_t::size_type GetIndex (iterator itr)
 
Vector_t::size_type GetIndex (const_iterator itr) const
 
template<typename U = store_type, enable_if_t<(is_pointer_t(U)), G4int > = 0>
T * GetObject (G4int idx) const
 
template<typename U = store_type, enable_if_t<(is_pointer_t(U)), G4int > = 0>
T * GetObject (iterator itr) const
 
template<typename U = store_type, enable_if_t<(is_pointer_t(U)), G4int > = 0>
const T * GetObject (const_iterator itr) const
 
template<typename U = store_type, enable_if_t<(!is_pointer_t(U)), G4int > = 0>
T * GetObject (G4int idx) const
 
template<typename U = store_type, enable_if_t<(!is_pointer_t(U)), G4int > = 0>
T * GetObject (iterator itr) const
 
template<typename U = store_type, enable_if_t<(!is_pointer_t(U)), G4int > = 0>
const T * GetObject (const_iterator itr) const
 
iterator begin ()
 
iterator end ()
 
const_iterator begin () const
 
const_iterator end () const
 
const_iterator cbegin () const
 
const_iterator cend () const
 
Vector_t * GetVector () const
 
std::size_t entries () const
 
void clear ()
 
virtual G4VHit * GetHit (std::size_t) const
 
virtual std::size_t GetSize () const
 
map_t * GetMap () const
 
template<typename U = T, typename V = store_type, enable_if_t<(is_fundamental_t(U) &&is_pointer_t(V)), G4int > = 0>
store_type allocate () const
 
template<typename U = T, typename V = store_type, enable_if_t<(!is_fundamental_t(U) &&is_pointer_t(V)), G4int > = 0>
store_type allocate () const
 
template<typename U = store_type, enable_if_t<(is_pointer_t(U)), G4int > = 0>
store_type null () const
 
template<typename U = T, typename V = store_type, enable_if_t<(is_fundamental_t(U) &&!is_pointer_t(V)), G4int > = 0>
store_type allocate () const
 
template<typename U = T, typename V = store_type, enable_if_t<(!is_fundamental_t(U) &&!is_pointer_t(V)), G4int > = 0>
store_type allocate () const
 
template<typename U = store_type, enable_if_t<(!is_pointer_t(U)), G4int > = 0>
store_type null () const
 
template<typename U , typename VectorU_t , enable_if_t<(is_pointer_t(typename VectorU_t::value_type)), G4int > = 0>
this_type & operator+= (const G4VTHitsVector< U, VectorU_t > &right) const
 
template<typename U , typename VectorU_t , enable_if_t<(!is_pointer_t(typename VectorU_t::value_type)), G4int > = 0>
this_type & operator+= (const G4VTHitsVector< U, VectorU_t > &right) const
 
template<typename U , typename MapU_t , enable_if_t<(is_pointer_t(typename MapU_t::mapped_type)), G4int > = 0>
this_type & operator+= (const G4VTHitsMap< U, MapU_t > &right) const
 
template<typename U , typename MapU_t , enable_if_t<!(is_pointer_t(typename MapU_t::mapped_type)), G4int > = 0>
this_type & operator+= (const G4VTHitsMap< U, MapU_t > &right) const
 
template<typename U = T, enable_if_t< is_same_t(U, T), G4int > = 0>
std::size_t add (const G4int &key, U *&aHit) const
 
template<typename U = T, enable_if_t<!is_same_t(U, T), G4int > = 0>
std::size_t add (const G4int &key, U *&aHit) const
 
template<typename U = T, enable_if_t< is_same_t(U, T), G4int > = 0>
std::size_t add (const G4int &key, U &aHit) const
 
template<typename U = T, enable_if_t<!is_same_t(U, T), G4int > = 0>
std::size_t add (const G4int &key, U &aHit) const
 
template<typename U = T, enable_if_t< is_same_t(U, T), G4int > = 0>
std::size_t set (const G4int &key, U *&aHit) const
 
template<typename U = T, enable_if_t<!is_same_t(U, T), G4int > = 0>
std::size_t set (const G4int &key, U *&aHit) const
 
template<typename U = T, enable_if_t< is_same_t(U, T), G4int > = 0>
std::size_t set (const G4int &key, U &aHit) const
 
template<typename U = T, enable_if_t<!is_same_t(U, T), G4int > = 0>
std::size_t set (const G4int &key, U &aHit) const
 
T * at (G4int key) const
 
T * operator[] (G4int key) const
 
- Public Member Functions inherited from G4HitsCollection
 G4HitsCollection ()
 
 G4HitsCollection (G4String detName, G4String colNam)
 
virtual ~G4HitsCollection ()
 
G4bool operator== (const G4HitsCollection &right) const
 
- Public Member Functions inherited from G4VHitsCollection
 G4VHitsCollection ()
 
 G4VHitsCollection (G4String detName, G4String colNam)
 
virtual ~G4VHitsCollection ()
 
G4bool operator== (const G4VHitsCollection &right) const
 
virtual void DrawAllHits ()
 
virtual void PrintAllHits ()
 
const G4String & GetName () const
 
const G4String & GetSDname () const
 
void SetColID (G4int i)
 
G4int GetColID () const
 
virtual G4VHit * GetHit (size_t) const
 
virtual size_t GetSize () const
 

Protected Member Functions

template<typename U = store_type, enable_if_t<(is_pointer_t(U)), G4int > = 0>
void resize (vector_type *&theHitsVector, const G4int &key) const
 
template<typename U = store_type, enable_if_t<(!is_pointer_t(U)), G4int > = 0>
void resize (vector_type *&theHitsVector, const G4int &key) const
 
vector_type * GetVector (const G4int &key) const
 
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void _assign (vector_type *&theHitsVector, const G4int &key, T &val) const
 
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void _assign (vector_type *&theHitsVector, const G4int &key, T *&val) const
 
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void _add (vector_type *&theHitsVector, const G4int &key, T &val) const
 
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void _add (vector_type *&theHitsVector, const G4int &key, T *&val) const
 
template<typename V , typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void _add (vector_type *&theHitsVector, const G4int &key, V &val) const
 
template<typename V , typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void _add (vector_type *&theHitsVector, const G4int &key, V *&val) const
 
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
T & get (U &val) const
 
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void delete_contents (vector_type *&theHitsVector) const
 
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
T & get_reference (U &val) const
 
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void _assign (vector_type *&theHitsVector, const G4int &key, T &val) const
 
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void _assign (vector_type *&theHitsVector, const G4int &key, T *&val) const
 
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void _add (vector_type *&theHitsVector, const G4int &key, T &val) const
 
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void _add (vector_type *&theHitsVector, const G4int &key, T *&val) const
 
template<typename V , typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void _add (vector_type *&theHitsVector, const G4int &key, V &val) const
 
template<typename V , typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void _add (vector_type *&theHitsVector, const G4int &key, V *&val) const
 
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void delete_contents (vector_type *&) const
 
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
T & get_reference (U &val) const
 

Additional Inherited Members

- Protected Attributes inherited from G4HitsCollection
void * theCollection
 
- Protected Attributes inherited from G4VHitsCollection
G4String collectionName
 
G4String SDname
 
G4int colID
 

Detailed Description

template<typename T, typename Vector_t = std::deque<T*>>
class G4VTHitsVector< T, Vector_t >

Definition at line 52 of file G4THitsVector.hh.

Member Typedef Documentation

◆ const_iterator

template<typename T , typename Vector_t = std::deque<T*>>
typedef vector_type::const_iterator G4VTHitsVector< T, Vector_t >::const_iterator

Definition at line 59 of file G4THitsVector.hh.

◆ iterator

template<typename T , typename Vector_t = std::deque<T*>>
typedef vector_type::iterator G4VTHitsVector< T, Vector_t >::iterator

Definition at line 58 of file G4THitsVector.hh.

◆ map_t

template<typename T , typename Vector_t = std::deque<T*>>
typedef std::map<G4int, store_type> G4VTHitsVector< T, Vector_t >::map_t

Definition at line 63 of file G4THitsVector.hh.

◆ mmap_t

template<typename T , typename Vector_t = std::deque<T*>>
typedef std::multimap<G4int, store_type> G4VTHitsVector< T, Vector_t >::mmap_t

Definition at line 65 of file G4THitsVector.hh.

◆ pair_t

template<typename T , typename Vector_t = std::deque<T*>>
typedef std::pair<G4int, store_type> G4VTHitsVector< T, Vector_t >::pair_t

Definition at line 62 of file G4THitsVector.hh.

◆ store_type

template<typename T , typename Vector_t = std::deque<T*>>
typedef Vector_t::value_type G4VTHitsVector< T, Vector_t >::store_type

Definition at line 61 of file G4THitsVector.hh.

◆ this_type

template<typename T , typename Vector_t = std::deque<T*>>
typedef G4VTHitsVector<T, Vector_t> G4VTHitsVector< T, Vector_t >::this_type

Definition at line 55 of file G4THitsVector.hh.

◆ uomap_t

template<typename T , typename Vector_t = std::deque<T*>>
typedef std::unordered_map<G4int, store_type> G4VTHitsVector< T, Vector_t >::uomap_t

Definition at line 64 of file G4THitsVector.hh.

◆ uommap_t

template<typename T , typename Vector_t = std::deque<T*>>
typedef std::unordered_multimap<G4int, store_type> G4VTHitsVector< T, Vector_t >::uommap_t

Definition at line 66 of file G4THitsVector.hh.

◆ value_type

template<typename T , typename Vector_t = std::deque<T*>>
typedef T G4VTHitsVector< T, Vector_t >::value_type

Definition at line 56 of file G4THitsVector.hh.

◆ vector_type

template<typename T , typename Vector_t = std::deque<T*>>
typedef Vector_t G4VTHitsVector< T, Vector_t >::vector_type

Definition at line 57 of file G4THitsVector.hh.

Constructor & Destructor Documentation

◆ G4VTHitsVector() [1/2]

template<typename T , typename Vector_t >
G4VTHitsVector< T, Vector_t >::G4VTHitsVector ( G4int  init_size = 0)

Definition at line 579 of file G4THitsVector.hh.

580{
581 theCollection = static_cast<void*>(new Vector_t);
582 if(init_size > 0)
583 {
584 vector_type* theHitsVector = GetVector();
585 resize(theHitsVector, init_size - 1);
586 }
587}
G4VTHitsVector::GetVector
Vector_t * GetVector() const
Definition: G4THitsVector.hh:164
G4VTHitsVector::resize
void resize(vector_type *&theHitsVector, const G4int &key) const
Definition: G4THitsVector.hh:419
G4VTHitsVector::vector_type
Vector_t vector_type
Definition: G4THitsVector.hh:57

◆ G4VTHitsVector() [2/2]

template<typename T , typename Vector_t >
G4VTHitsVector< T, Vector_t >::G4VTHitsVector ( G4String  detName,
G4String  colNam,
G4int  init_size = 0 
)

Definition at line 592 of file G4THitsVector.hh.

594 : G4HitsCollection(detName, colNam)
595{
596 theCollection = static_cast<void*>(new Vector_t);
597 if(init_size > 0)
598 {
599 vector_type* theHitsVector = GetVector();
600 resize(theHitsVector, init_size - 1);
601 }
602}

◆ ~G4VTHitsVector()

template<typename T , typename Vector_t >
G4VTHitsVector< T, Vector_t >::~G4VTHitsVector
virtual

Definition at line 607 of file G4THitsVector.hh.

608{
609 vector_type* theHitsVector = GetVector();
610 delete_contents(theHitsVector);
611 delete theHitsVector;
612}
G4VTHitsVector::delete_contents
void delete_contents(vector_type *&theHitsVector) const
Definition: G4THitsVector.hh:499

Member Function Documentation

◆ _add() [1/8]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_add ( vector_type *&  theHitsVector,
const G4int &  key,
T &  val 
) const
inlineprotected

Definition at line 467 of file G4THitsVector.hh.

468 {
469 *(*theHitsVector)[key] += val;
470 }

Referenced by G4VTHitsVector< T, Vector_t >::add().

◆ _add() [2/8]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_add ( vector_type *&  theHitsVector,
const G4int &  key,
T &  val 
) const
inlineprotected

Definition at line 530 of file G4THitsVector.hh.

531 {
532 (*theHitsVector)[key] += val;
533 }

◆ _add() [3/8]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_add ( vector_type *&  theHitsVector,
const G4int &  key,
T *&  val 
) const
inlineprotected

Definition at line 473 of file G4THitsVector.hh.

474 {
475 *(*theHitsVector)[key] += *val;
476 }

◆ _add() [4/8]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_add ( vector_type *&  theHitsVector,
const G4int &  key,
T *&  val 
) const
inlineprotected

Definition at line 536 of file G4THitsVector.hh.

537 {
538 (*theHitsVector)[key] += *val;
539 }

◆ _add() [5/8]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename V , typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_add ( vector_type *&  theHitsVector,
const G4int &  key,
V &  val 
) const
inlineprotected

Definition at line 480 of file G4THitsVector.hh.

481 {
482 *(*theHitsVector)[key] += val;
483 }

◆ _add() [6/8]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename V , typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_add ( vector_type *&  theHitsVector,
const G4int &  key,
V &  val 
) const
inlineprotected

Definition at line 543 of file G4THitsVector.hh.

544 {
545 (*theHitsVector)[key] += val;
546 }

◆ _add() [7/8]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename V , typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_add ( vector_type *&  theHitsVector,
const G4int &  key,
V *&  val 
) const
inlineprotected

Definition at line 487 of file G4THitsVector.hh.

488 {
489 *(*theHitsVector)[key] += *val;
490 }

◆ _add() [8/8]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename V , typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_add ( vector_type *&  theHitsVector,
const G4int &  key,
V *&  val 
) const
inlineprotected

Definition at line 550 of file G4THitsVector.hh.

551 {
552 (*theHitsVector)[key] += *val;
553 }

◆ _assign() [1/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_assign ( vector_type *&  theHitsVector,
const G4int &  key,
T &  val 
) const
inlineprotected

Definition at line 453 of file G4THitsVector.hh.

454 {
455 delete(*theHitsVector)[key];
456 *(*theHitsVector)[key] = val;
457 }

Referenced by G4VTHitsVector< T, Vector_t >::resize(), and G4VTHitsVector< T, Vector_t >::set().

◆ _assign() [2/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_assign ( vector_type *&  theHitsVector,
const G4int &  key,
T &  val 
) const
inlineprotected

Definition at line 517 of file G4THitsVector.hh.

518 {
519 (*theHitsVector)[key] = val;
520 }

◆ _assign() [3/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_assign ( vector_type *&  theHitsVector,
const G4int &  key,
T *&  val 
) const
inlineprotected

Definition at line 460 of file G4THitsVector.hh.

461 {
462 delete(*theHitsVector)[key];
463 (*theHitsVector)[key] = val;
464 }

◆ _assign() [4/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::_assign ( vector_type *&  theHitsVector,
const G4int &  key,
T *&  val 
) const
inlineprotected

Definition at line 523 of file G4THitsVector.hh.

524 {
525 delete(*theHitsVector)[key];
526 (*theHitsVector)[key] = *val;
527 }

◆ add() [1/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, enable_if_t< is_same_t(U, T), G4int > = 0>
std::size_t G4VTHitsVector< T, Vector_t >::add ( const G4int &  key,
U &  aHit 
) const
inline

Definition at line 326 of file G4THitsVector.hh.

327 {
328 vector_type* theHitsVector = GetVector(key);
329 _add(theHitsVector, key, aHit);
330 return theHitsVector->size();
331 }
G4VTHitsVector::_add
void _add(vector_type *&theHitsVector, const G4int &key, T &val) const
Definition: G4THitsVector.hh:467

◆ add() [2/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, enable_if_t<!is_same_t(U, T), G4int > = 0>
std::size_t G4VTHitsVector< T, Vector_t >::add ( const G4int &  key,
U &  aHit 
) const
inline

Definition at line 336 of file G4THitsVector.hh.

337 {
338 vector_type* theHitsVector = GetVector(key);
339 _add(theHitsVector, key, aHit);
340 return theHitsVector->size();
341 }

◆ add() [3/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, enable_if_t< is_same_t(U, T), G4int > = 0>
std::size_t G4VTHitsVector< T, Vector_t >::add ( const G4int &  key,
U *&  aHit 
) const
inline

Definition at line 304 of file G4THitsVector.hh.

305 {
306 vector_type* theHitsVector = GetVector(key);
307 _add(theHitsVector, key, *aHit);
308 return theHitsVector->size();
309 }

◆ add() [4/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, enable_if_t<!is_same_t(U, T), G4int > = 0>
std::size_t G4VTHitsVector< T, Vector_t >::add ( const G4int &  key,
U *&  aHit 
) const
inline

Definition at line 314 of file G4THitsVector.hh.

315 {
316 vector_type* theHitsVector = GetVector(key);
317 store_type hit = allocate();
318 get_reference(hit) += *aHit;
319 _add(theHitsVector, key, *hit);
320 return theHitsVector->size();
321 }
G4VTHitsVector::store_type
Vector_t::value_type store_type
Definition: G4THitsVector.hh:61
G4VTHitsVector::allocate
store_type allocate() const
Definition: G4THitsVector.hh:191
G4VTHitsVector::get_reference
T & get_reference(U &val) const
Definition: G4THitsVector.hh:507

◆ allocate() [1/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, typename V = store_type, enable_if_t<(is_fundamental_t(U) &&is_pointer_t(V)), G4int > = 0>
store_type G4VTHitsVector< T, Vector_t >::allocate ( ) const
inline

Definition at line 191 of file G4THitsVector.hh.

192 {
193 return new T(0.);
194 }

Referenced by G4VTHitsVector< T, Vector_t >::add(), G4VTHitsVector< T, Vector_t >::operator+=(), G4VTHitsVector< T, Vector_t >::resize(), and G4VTHitsVector< T, Vector_t >::set().

◆ allocate() [2/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, typename V = store_type, enable_if_t<(!is_fundamental_t(U) &&is_pointer_t(V)), G4int > = 0>
store_type G4VTHitsVector< T, Vector_t >::allocate ( ) const
inline

Definition at line 200 of file G4THitsVector.hh.

201 {
202 return new T();
203 }

◆ allocate() [3/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, typename V = store_type, enable_if_t<(is_fundamental_t(U) &&!is_pointer_t(V)), G4int > = 0>
store_type G4VTHitsVector< T, Vector_t >::allocate ( ) const
inline

Definition at line 218 of file G4THitsVector.hh.

219 {
220 return T(0.);
221 }

◆ allocate() [4/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, typename V = store_type, enable_if_t<(!is_fundamental_t(U) &&!is_pointer_t(V)), G4int > = 0>
store_type G4VTHitsVector< T, Vector_t >::allocate ( ) const
inline

Definition at line 226 of file G4THitsVector.hh.

227 {
228 return T();
229 }

◆ at()

template<typename T , typename Vector_t = std::deque<T*>>
T * G4VTHitsVector< T, Vector_t >::at ( G4int  key) const
inline

Definition at line 402 of file G4THitsVector.hh.

403 {
404 vector_type* theHitsVector = GetVector();
405 resize(theHitsVector, key);
406 return &get_reference((*theHitsVector)[key]);
407 }

◆ begin() [1/2]

template<typename T , typename Vector_t = std::deque<T*>>
iterator G4VTHitsVector< T, Vector_t >::begin ( )
inline

Definition at line 156 of file G4THitsVector.hh.

156{ return GetContainer()->begin(); }
G4VTHitsVector::GetContainer
Vector_t * GetContainer() const
Definition: G4THitsVector.hh:101

Referenced by G4VTHitsVector< T, Vector_t >::GetIndex().

◆ begin() [2/2]

template<typename T , typename Vector_t = std::deque<T*>>
const_iterator G4VTHitsVector< T, Vector_t >::begin ( ) const
inline

Definition at line 158 of file G4THitsVector.hh.

158{ return GetContainer()->begin(); }

◆ cbegin()

template<typename T , typename Vector_t = std::deque<T*>>
const_iterator G4VTHitsVector< T, Vector_t >::cbegin ( ) const
inline

Definition at line 160 of file G4THitsVector.hh.

160{ return GetContainer()->cbegin(); }

◆ cend()

template<typename T , typename Vector_t = std::deque<T*>>
const_iterator G4VTHitsVector< T, Vector_t >::cend ( ) const
inline

Definition at line 161 of file G4THitsVector.hh.

161{ return GetContainer()->cend(); }

◆ clear()

template<typename T , typename Vector_t >
void G4VTHitsVector< T, Vector_t >::clear
inline

Definition at line 672 of file G4THitsVector.hh.

673{
674 vector_type* theHitsVector = GetVector();
675 delete_contents(theHitsVector);
676 theHitsVector->clear();
677}

◆ delete_contents() [1/2]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::delete_contents ( vector_type *&  ) const
inlineprotected

Definition at line 556 of file G4THitsVector.hh.

557 {}

◆ delete_contents() [2/2]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::delete_contents ( vector_type *&  theHitsVector) const
inlineprotected

Definition at line 499 of file G4THitsVector.hh.

500 {
501 for(iterator itr = theHitsVector->begin(); itr != theHitsVector->end();
502 ++itr)
503 delete *itr;
504 }
G4VTHitsVector::iterator
vector_type::iterator iterator
Definition: G4THitsVector.hh:58

◆ DrawAllHits()

template<typename T , typename Vector_t >
void G4VTHitsVector< T, Vector_t >::DrawAllHits
virtual

Reimplemented from G4VHitsCollection.

Definition at line 643 of file G4THitsVector.hh.

644{
645 ;
646}

◆ end() [1/2]

template<typename T , typename Vector_t = std::deque<T*>>
iterator G4VTHitsVector< T, Vector_t >::end ( )
inline

Definition at line 157 of file G4THitsVector.hh.

157{ return GetContainer()->end(); }

◆ end() [2/2]

template<typename T , typename Vector_t = std::deque<T*>>
const_iterator G4VTHitsVector< T, Vector_t >::end ( ) const
inline

Definition at line 159 of file G4THitsVector.hh.

159{ return GetContainer()->end(); }

◆ entries()

template<typename T , typename Vector_t = std::deque<T*>>
std::size_t G4VTHitsVector< T, Vector_t >::entries ( ) const
inline

Definition at line 168 of file G4THitsVector.hh.

169 {
170 return (scast(Vector_t*)(theCollection))->size();
171 }
scast
#define scast(_Tp)
Definition: G4THitsVector.hh:80

◆ get()

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
T & G4VTHitsVector< T, Vector_t >::get ( U &  val) const
inlineprotected

Definition at line 493 of file G4THitsVector.hh.

494 {
495 return *val;
496 }

◆ get_reference() [1/2]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t< is_pointer_t(U), G4int > = 0>
T & G4VTHitsVector< T, Vector_t >::get_reference ( U &  val) const
inlineprotected

Definition at line 507 of file G4THitsVector.hh.

508 {
509 return *val;
510 }

Referenced by G4VTHitsVector< T, Vector_t >::add(), G4VTHitsVector< T, Vector_t >::at(), G4VTHitsVector< T, Vector_t >::operator[](), and G4VTHitsVector< T, Vector_t >::set().

◆ get_reference() [2/2]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<!is_pointer_t(U), G4int > = 0>
T & G4VTHitsVector< T, Vector_t >::get_reference ( U &  val) const
inlineprotected

Definition at line 560 of file G4THitsVector.hh.

561 {
562 return val;
563 }

◆ GetContainer()

template<typename T , typename Vector_t = std::deque<T*>>
Vector_t * G4VTHitsVector< T, Vector_t >::GetContainer ( ) const
inline

Definition at line 101 of file G4THitsVector.hh.

102 {
103 return scast(Vector_t*)(theCollection);
104 }

Referenced by G4VTHitsVector< T, Vector_t >::begin(), G4VTHitsVector< T, Vector_t >::cbegin(), G4VTHitsVector< T, Vector_t >::cend(), G4VTHitsVector< T, Vector_t >::end(), G4VTHitsVector< T, Vector_t >::GetObject(), and G4VTHitsVector< T, Vector_t >::size().

◆ GetHit()

template<typename T , typename Vector_t = std::deque<T*>>
virtual G4VHit * G4VTHitsVector< T, Vector_t >::GetHit ( std::size_t  ) const
inlinevirtual

Definition at line 176 of file G4THitsVector.hh.

176{ return nullptr; }

◆ GetIndex() [1/2]

template<typename T , typename Vector_t = std::deque<T*>>
Vector_t::size_type G4VTHitsVector< T, Vector_t >::GetIndex ( const_iterator  itr) const
inline

Definition at line 113 of file G4THitsVector.hh.

114 {
115 return std::distance(begin(), itr);
116 }
G4VTHitsVector::begin
iterator begin()
Definition: G4THitsVector.hh:156

◆ GetIndex() [2/2]

template<typename T , typename Vector_t = std::deque<T*>>
Vector_t::size_type G4VTHitsVector< T, Vector_t >::GetIndex ( iterator  itr)
inline

Definition at line 108 of file G4THitsVector.hh.

109 {
110 return std::distance(begin(), itr);
111 }

◆ GetMap()

template<typename T , typename Vector_t >
G4VTHitsVector< T, Vector_t >::map_t * G4VTHitsVector< T, Vector_t >::GetMap
inline

Definition at line 627 of file G4THitsVector.hh.

628{
629 G4ThreadLocalStatic map_t* theHitsMap = new map_t();
630 theHitsMap->clear();
631 vector_type* theHitsVector = GetVector();
632 for(std::size_t i = 0; i < theHitsVector->size(); ++i)
633 {
634 store_type& _obj = (*theHitsVector)[i];
635 if(_obj)
636 (*theHitsMap)[i] = _obj;
637 }
638 return theHitsMap;
639}
G4VTHitsVector::map_t
std::map< G4int, store_type > map_t
Definition: G4THitsVector.hh:63
G4ThreadLocalStatic
#define G4ThreadLocalStatic
Definition: tls.hh:76

◆ GetObject() [1/6]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<(is_pointer_t(U)), G4int > = 0>
const T * G4VTHitsVector< T, Vector_t >::GetObject ( const_iterator  itr) const
inline

Definition at line 132 of file G4THitsVector.hh.

133 {
134 return (*itr);
135 }

◆ GetObject() [2/6]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<(!is_pointer_t(U)), G4int > = 0>
const T * G4VTHitsVector< T, Vector_t >::GetObject ( const_iterator  itr) const
inline

Definition at line 151 of file G4THitsVector.hh.

152 {
153 return &(*itr);
154 }

◆ GetObject() [3/6]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<(is_pointer_t(U)), G4int > = 0>
T * G4VTHitsVector< T, Vector_t >::GetObject ( G4int  idx) const
inline

Definition at line 119 of file G4THitsVector.hh.

120 {
121 return (idx < (G4int) GetContainer()->size()) ? (*GetContainer())[idx]
122 : nullptr;
123 }
G4int
int G4int
Definition: G4Types.hh:85
G4VTHitsVector::size
Vector_t::size_type size()
Definition: G4THitsVector.hh:106

◆ GetObject() [4/6]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<(!is_pointer_t(U)), G4int > = 0>
T * G4VTHitsVector< T, Vector_t >::GetObject ( G4int  idx) const
inline

Definition at line 138 of file G4THitsVector.hh.

139 {
140 return (idx < (G4int) GetContainer()->size()) ? &(*GetContainer())[idx]
141 : nullptr;
142 }

◆ GetObject() [5/6]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<(is_pointer_t(U)), G4int > = 0>
T * G4VTHitsVector< T, Vector_t >::GetObject ( iterator  itr) const
inline

Definition at line 126 of file G4THitsVector.hh.

127 {
128 return (*itr);
129 }

◆ GetObject() [6/6]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<(!is_pointer_t(U)), G4int > = 0>
T * G4VTHitsVector< T, Vector_t >::GetObject ( iterator  itr) const
inline

Definition at line 145 of file G4THitsVector.hh.

146 {
147 return &(*itr);
148 }

◆ GetSize()

template<typename T , typename Vector_t = std::deque<T*>>
virtual std::size_t G4VTHitsVector< T, Vector_t >::GetSize ( ) const
inlinevirtual

Reimplemented from G4VHitsCollection.

Definition at line 177 of file G4THitsVector.hh.

178 {
179 return (scast(Vector_t*)(theCollection))->size();
180 }

◆ GetVector() [1/2]

template<typename T , typename Vector_t = std::deque<T*>>
Vector_t * G4VTHitsVector< T, Vector_t >::GetVector ( ) const
inline

Definition at line 164 of file G4THitsVector.hh.

164{ return scast(Vector_t*)(theCollection); }

Referenced by G4VTHitsVector< T, Vector_t >::add(), G4VTHitsVector< T, Vector_t >::at(), G4VTHitsVector< T, Vector_t >::G4VTHitsVector(), G4VTHitsVector< T, Vector_t >::GetVector(), G4VTHitsVector< T, Vector_t >::operator+=(), G4VTHitsVector< T, Vector_t >::operator[](), and G4VTHitsVector< T, Vector_t >::set().

◆ GetVector() [2/2]

template<typename T , typename Vector_t = std::deque<T*>>
vector_type * G4VTHitsVector< T, Vector_t >::GetVector ( const G4int &  key) const
inlineprotected

Definition at line 441 of file G4THitsVector.hh.

442 {
443 vector_type* theHitsVector = GetVector();
444 resize(theHitsVector, key);
445 return theHitsVector;
446 }

◆ null() [1/2]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<(is_pointer_t(U)), G4int > = 0>
store_type G4VTHitsVector< T, Vector_t >::null ( ) const
inline

Definition at line 207 of file G4THitsVector.hh.

208 {
209 return nullptr;
210 }

Referenced by G4VTHitsVector< T, Vector_t >::operator+=(), and G4VTHitsVector< T, Vector_t >::resize().

◆ null() [2/2]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<(!is_pointer_t(U)), G4int > = 0>
store_type G4VTHitsVector< T, Vector_t >::null ( ) const
inline

Definition at line 233 of file G4THitsVector.hh.

234 {
235 return store_type();
236 }

◆ operator+=() [1/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U , typename MapU_t , enable_if_t<(is_pointer_t(typename MapU_t::mapped_type)), G4int > = 0>
this_type & G4VTHitsVector< T, Vector_t >::operator+= ( const G4VTHitsMap< U, MapU_t > &  right) const
inline

Definition at line 275 of file G4THitsVector.hh.

276 {
277 MapU_t* aHitsMap = right.GetMap();
278 for(auto itr = aHitsMap->begin(); itr != aHitsMap->end(); ++itr)
279 add<U>(itr->first, *(itr->second));
280 return static_cast<this_type&>(*(const_cast<this_type*>(this)));
281 }
G4VTHitsMap::GetMap
Map_t * GetMap() const
Definition: G4THitsMap.hh:155
G4VTHitsVector::this_type
G4VTHitsVector< T, Vector_t > this_type
Definition: G4THitsVector.hh:55

◆ operator+=() [2/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U , typename MapU_t , enable_if_t<!(is_pointer_t(typename MapU_t::mapped_type)), G4int > = 0>
this_type & G4VTHitsVector< T, Vector_t >::operator+= ( const G4VTHitsMap< U, MapU_t > &  right) const
inline

Definition at line 286 of file G4THitsVector.hh.

287 {
288 MapU_t* aHitsMap = right.GetMap();
289 for(auto itr = aHitsMap->begin(); itr != aHitsMap->end(); ++itr)
290 add<U>(itr->first, itr->second);
291 return static_cast<this_type&>(*(const_cast<this_type*>(this)));
292 }

◆ operator+=() [3/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U , typename VectorU_t , enable_if_t<(is_pointer_t(typename VectorU_t::value_type)), G4int > = 0>
this_type & G4VTHitsVector< T, Vector_t >::operator+= ( const G4VTHitsVector< U, VectorU_t > &  right) const
inline

Definition at line 246 of file G4THitsVector.hh.

247 {
248 VectorU_t* aHitsVector = right.GetVector();
249 for(auto itr = aHitsVector->begin(); itr != aHitsVector->end(); ++itr)
250 {
251 auto _ptr = (*itr) ? (*itr) : null();
252 if(_ptr)
253 add<U>(std::distance(aHitsVector->begin(), itr), *_ptr);
254 }
255 return static_cast<this_type&>(*(const_cast<this_type*>(this)));
256 }
G4VTHitsVector::null
store_type null() const
Definition: G4THitsVector.hh:207

◆ operator+=() [4/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U , typename VectorU_t , enable_if_t<(!is_pointer_t(typename VectorU_t::value_type)), G4int > = 0>
this_type & G4VTHitsVector< T, Vector_t >::operator+= ( const G4VTHitsVector< U, VectorU_t > &  right) const
inline

Definition at line 261 of file G4THitsVector.hh.

262 {
263 VectorU_t* aHitsVector = right.GetVector();
264 for(auto itr = aHitsVector->begin(); itr != aHitsVector->end(); ++itr)
265 {
266 auto _ptr = (*itr) ? (*itr) : allocate();
267 add<U>(std::distance(aHitsVector->begin(), itr), _ptr);
268 }
269 return static_cast<this_type&>(*(const_cast<this_type*>(this)));
270 }

◆ operator==()

template<typename T , typename Vector_t >
G4bool G4VTHitsVector< T, Vector_t >::operator== ( const this_type &  rhs) const

Definition at line 617 of file G4THitsVector.hh.

619{
620 return (collectionName == right.collectionName);
621}

◆ operator[]()

template<typename T , typename Vector_t = std::deque<T*>>
T * G4VTHitsVector< T, Vector_t >::operator[] ( G4int  key) const
inline

Definition at line 409 of file G4THitsVector.hh.

410 {
411 vector_type* theHitsVector = GetVector();
412 resize(theHitsVector, key);
413 return &get_reference((*theHitsVector)[key]);
414 }

◆ PrintAllHits()

template<typename T , typename Vector_t >
void G4VTHitsVector< T, Vector_t >::PrintAllHits
virtual

Reimplemented from G4VHitsCollection.

Definition at line 651 of file G4THitsVector.hh.

652{
653 G4cout << "G4THitsVector " << SDname << " / " << collectionName << " --- "
654 << entries() << " entries" << G4endl;
655 /*----- commented out for the use-case where <T> cannot be initialized
656 to be zero or does not support += operator.
657 Vector_t * theHitsVector = GetVector();
658 typename Vector_t::iterator itr = theHitsVector->begin();
659 T sum = 0.;
660 for(; itr != theHitsVector->end(); ++itr) {
661 G4cout << " " << itr->first << " : "
662 << *(itr->second) << G4endl;
663 sum += *(itr->second);
664 }
665 G4cout << " Total : " << sum << G4endl;
666 ----------------------------------------------------------------------*/
667}
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
G4VTHitsVector::entries
std::size_t entries() const
Definition: G4THitsVector.hh:168

◆ resize() [1/2]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<(is_pointer_t(U)), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::resize ( vector_type *&  theHitsVector,
const G4int &  key 
) const
inlineprotected

Definition at line 419 of file G4THitsVector.hh.

420 {
421 // ensure the proper size
422 if(key >= (G4int) theHitsVector->size())
423 theHitsVector->resize(key + 1, null());
424
425 // if null pointer for vector entry: allocate
426 if(!theHitsVector->at(key))
427 {
428 store_type init = allocate();
429 _assign(theHitsVector, key, init);
430 }
431 }
G4VTHitsVector::_assign
void _assign(vector_type *&theHitsVector, const G4int &key, T &val) const
Definition: G4THitsVector.hh:453

Referenced by G4VTHitsVector< T, Vector_t >::at(), G4VTHitsVector< T, Vector_t >::G4VTHitsVector(), G4VTHitsVector< T, Vector_t >::GetVector(), and G4VTHitsVector< T, Vector_t >::operator[]().

◆ resize() [2/2]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = store_type, enable_if_t<(!is_pointer_t(U)), G4int > = 0>
void G4VTHitsVector< T, Vector_t >::resize ( vector_type *&  theHitsVector,
const G4int &  key 
) const
inlineprotected

Definition at line 434 of file G4THitsVector.hh.

435 {
436 // ensure the proper size
437 if(key >= (G4int) theHitsVector->size())
438 theHitsVector->resize(key + 1, null());
439 }

◆ set() [1/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, enable_if_t< is_same_t(U, T), G4int > = 0>
std::size_t G4VTHitsVector< T, Vector_t >::set ( const G4int &  key,
U &  aHit 
) const
inline

Definition at line 380 of file G4THitsVector.hh.

381 {
382 vector_type* theHitsVector = GetVector(key);
383 _assign(theHitsVector, key, &aHit);
384 return theHitsVector->size();
385 }

◆ set() [2/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, enable_if_t<!is_same_t(U, T), G4int > = 0>
std::size_t G4VTHitsVector< T, Vector_t >::set ( const G4int &  key,
U &  aHit 
) const
inline

Definition at line 390 of file G4THitsVector.hh.

391 {
392 vector_type* theHitsVector = GetVector(key);
393 store_type hit = allocate();
394 get_reference(hit) += aHit;
395 _assign(theHitsVector, key, &aHit);
396 return theHitsVector->size();
397 }

◆ set() [3/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, enable_if_t< is_same_t(U, T), G4int > = 0>
std::size_t G4VTHitsVector< T, Vector_t >::set ( const G4int &  key,
U *&  aHit 
) const
inline

Definition at line 352 of file G4THitsVector.hh.

353 {
354 vector_type* theHitsVector = GetVector(key);
355 _assign(theHitsVector, key, aHit);
356 return theHitsVector->size();
357 }

◆ set() [4/4]

template<typename T , typename Vector_t = std::deque<T*>>
template<typename U = T, enable_if_t<!is_same_t(U, T), G4int > = 0>
std::size_t G4VTHitsVector< T, Vector_t >::set ( const G4int &  key,
U *&  aHit 
) const
inline

Definition at line 362 of file G4THitsVector.hh.

363 {
364 vector_type* theHitsVector = GetVector(key);
365 store_type hit = allocate();
366 get_reference(hit) += *aHit;
367 _assign(theHitsVector, key, hit);
368 return theHitsVector->size();
369 }

◆ size()

template<typename T , typename Vector_t = std::deque<T*>>
Vector_t::size_type G4VTHitsVector< T, Vector_t >::size ( )
inline

Definition at line 106 of file G4THitsVector.hh.

106{ return GetContainer()->size(); }

Referenced by G4VTHitsVector< T, Vector_t >::GetObject().

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