Geant4 11.4.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > Class Template Reference

#include <G4AccUnorderedMap.hh>

Inheritance diagram for G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >:

Public Member Functions

 G4AccUnorderedMap (const G4String &name="", G4MergeMode mergeMode=G4MergeMode::kAddition)
 G4AccUnorderedMap (std::size_t bucket_count, G4MergeMode mergeMode=G4MergeMode::kAddition, const Allocator &alloc=Allocator())
 G4AccUnorderedMap (const G4String &name, std::size_t bucket_count, G4MergeMode mergeMode=G4MergeMode::kAddition, const Allocator &alloc=Allocator())
 G4AccUnorderedMap (std::size_t bucket_count, const Allocator &alloc, G4MergeMode mergeMode=G4MergeMode::kAddition)
 G4AccUnorderedMap (const G4String &name, std::size_t bucket_count, const Allocator &alloc, G4MergeMode mergeMode=G4MergeMode::kAddition)
 G4AccUnorderedMap (std::size_t bucket_count, const Hash &hash, const Allocator &alloc, G4MergeMode mergeMode=G4MergeMode::kAddition)
 G4AccUnorderedMap (const G4String &name, std::size_t bucket_count, const Hash &hash, const Allocator &alloc, G4MergeMode mergeMode=G4MergeMode::kAddition)
 G4AccUnorderedMap (const Allocator &alloc, G4MergeMode mergeMode=G4MergeMode::kAddition)
 G4AccUnorderedMap (const G4String &name, const Allocator &alloc, G4MergeMode mergeMode=G4MergeMode::kAddition)
 G4AccUnorderedMap (std::initializer_list< std::pair< const Key, T > > init, G4MergeMode mergeMode=G4MergeMode::kAddition, std::size_t bucket_count=0, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
 G4AccUnorderedMap (const G4String &name, std::initializer_list< std::pair< const Key, T > > init, G4MergeMode mergeMode=G4MergeMode::kAddition, std::size_t bucket_count=0, const Hash &hash=Hash(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
 G4AccUnorderedMap (const G4AccUnorderedMap &rhs)=default
 G4AccUnorderedMap (const G4AccUnorderedMap &rhs, const Allocator &allocator)
 G4AccUnorderedMap (G4AccUnorderedMap &&rhs)=default
 G4AccUnorderedMap (G4AccUnorderedMap &&rhs, const Allocator &allocator)
 ~G4AccUnorderedMap () override=default
T & operator[] (const Key &key)
T & operator[] (Key &&key)
T & at (const Key &key)
const T & at (const Key &key) const
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::size_type size () const
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator begin ()
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::const_iterator begin () const
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::const_iterator cbegin () const
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator end ()
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::const_iterator end () const
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::const_iterator cend () const
void clear ()
std::pair< typename std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator, bool > insert (const T &value)
template<class P>
std::pair< typename std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator, bool > insert (P &&value)
std::pair< typename std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator, bool > insert (T &&value)
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator find (const Key &key)
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::const_iterator find (const Key &key) const
void Merge (const G4VAccumulable &other) final
void Reset () final
void Print (G4PrintOptions options=G4PrintOptions()) const final
void SetMergeMode (G4MergeMode value) final
void SetInitValue (const T &value)
G4AccType GetType () const final
std::unordered_map< Key, T, Hash, KeyEqual, Allocator > & GetUnorderedMap ()
const std::unordered_map< Key, T, Hash, KeyEqual, Allocator > & GetUnorderedMap () const
Public Member Functions inherited from G4VAccumulable
 G4VAccumulable (G4MergeMode mergeMode=G4MergeMode::kAddition)
 G4VAccumulable (const G4String &name, G4MergeMode mergeMode=G4MergeMode::kAddition)
 G4VAccumulable (const G4VAccumulable &rhs)=default
 G4VAccumulable (G4VAccumulable &&rhs)=default
virtual ~G4VAccumulable ()=default
G4VAccumulable & operator= (const G4VAccumulable &rhs)=default
G4VAccumulable & operator= (G4VAccumulable &&rhs)=default
void SetName (const G4String &name)
void SetId (G4int id)
G4String GetName () const
G4MergeMode GetMergeMode () const
G4int GetId () const

Additional Inherited Members

Protected Member Functions inherited from G4VAccumulable
void PrintBase (G4PrintOptions options) const
Protected Attributes inherited from G4VAccumulable
G4String fName
G4MergeMode fMergeMode = G4MergeMode::kAddition
G4int fId = G4Accumulables::kInvalidId

Detailed Description

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
class G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >

Definition at line 46 of file G4AccUnorderedMap.hh.

Constructor & Destructor Documentation

◆ G4AccUnorderedMap() [1/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( const G4String & name = "",
G4MergeMode mergeMode = G4MergeMode::kAddition )

Referenced by G4AccUnorderedMap(), G4AccUnorderedMap(), G4AccUnorderedMap(), and G4AccUnorderedMap().

◆ G4AccUnorderedMap() [2/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( std::size_t bucket_count,
G4MergeMode mergeMode = G4MergeMode::kAddition,
const Allocator & alloc = Allocator() )

◆ G4AccUnorderedMap() [3/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( const G4String & name,
std::size_t bucket_count,
G4MergeMode mergeMode = G4MergeMode::kAddition,
const Allocator & alloc = Allocator() )

◆ G4AccUnorderedMap() [4/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( std::size_t bucket_count,
const Allocator & alloc,
G4MergeMode mergeMode = G4MergeMode::kAddition )

◆ G4AccUnorderedMap() [5/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( const G4String & name,
std::size_t bucket_count,
const Allocator & alloc,
G4MergeMode mergeMode = G4MergeMode::kAddition )

◆ G4AccUnorderedMap() [6/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( std::size_t bucket_count,
const Hash & hash,
const Allocator & alloc,
G4MergeMode mergeMode = G4MergeMode::kAddition )

◆ G4AccUnorderedMap() [7/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( const G4String & name,
std::size_t bucket_count,
const Hash & hash,
const Allocator & alloc,
G4MergeMode mergeMode = G4MergeMode::kAddition )

◆ G4AccUnorderedMap() [8/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( const Allocator & alloc,
G4MergeMode mergeMode = G4MergeMode::kAddition )

◆ G4AccUnorderedMap() [9/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( const G4String & name,
const Allocator & alloc,
G4MergeMode mergeMode = G4MergeMode::kAddition )

◆ G4AccUnorderedMap() [10/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( std::initializer_list< std::pair< const Key, T > > init,
G4MergeMode mergeMode = G4MergeMode::kAddition,
std::size_t bucket_count = 0,
const Hash & hash = Hash(),
const KeyEqual & equal = KeyEqual(),
const Allocator & alloc = Allocator() )

◆ G4AccUnorderedMap() [11/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( const G4String & name,
std::initializer_list< std::pair< const Key, T > > init,
G4MergeMode mergeMode = G4MergeMode::kAddition,
std::size_t bucket_count = 0,
const Hash & hash = Hash(),
const KeyEqual & equal = KeyEqual(),
const Allocator & alloc = Allocator() )

◆ G4AccUnorderedMap() [12/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( const G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > & rhs)
default

◆ G4AccUnorderedMap() [13/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( const G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > & rhs,
const Allocator & allocator )

◆ G4AccUnorderedMap() [14/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > && rhs)
default

◆ G4AccUnorderedMap() [15/15]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::G4AccUnorderedMap ( G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > && rhs,
const Allocator & allocator )

◆ ~G4AccUnorderedMap()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::~G4AccUnorderedMap ( )
overridedefault

Member Function Documentation

◆ at() [1/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
T & G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::at ( const Key & key)
inline

Definition at line 211 of file G4AccUnorderedMap.hh.

211{ return fUMap[key]; }

◆ at() [2/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
const T & G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::at ( const Key & key) const
inline

Definition at line 212 of file G4AccUnorderedMap.hh.

212{ return fUMap[key]; }

◆ begin() [1/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::begin ( )
inline

Definition at line 216 of file G4AccUnorderedMap.hh.

216{ return fUMap.begin(); }

◆ begin() [2/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::const_iterator G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::begin ( ) const
inline

Definition at line 217 of file G4AccUnorderedMap.hh.

217{ return fUMap.begin(); }

◆ cbegin()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::const_iterator G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::cbegin ( ) const
inline

Definition at line 218 of file G4AccUnorderedMap.hh.

218{ return fUMap.cbegin(); }

◆ cend()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::const_iterator G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::cend ( ) const
inline

Definition at line 222 of file G4AccUnorderedMap.hh.

222{ return fUMap.cend(); }

◆ clear()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
void G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::clear ( )
inline

Definition at line 224 of file G4AccUnorderedMap.hh.

224{ fUMap.clear(); }

◆ end() [1/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::end ( )
inline

Definition at line 220 of file G4AccUnorderedMap.hh.

220{ return fUMap.end(); }

◆ end() [2/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::const_iterator G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::end ( ) const
inline

Definition at line 221 of file G4AccUnorderedMap.hh.

221{ return fUMap.end(); }

◆ find() [1/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::find ( const Key & key)
inline

Definition at line 231 of file G4AccUnorderedMap.hh.

231{ return fUMap.find(key); }

◆ find() [2/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::const_iterator G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::find ( const Key & key) const
inline

Definition at line 232 of file G4AccUnorderedMap.hh.

232{ return fUMap.find(key); }

◆ GetType()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccType G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::GetType ( ) const
inlinefinalvirtual

Reimplemented from G4VAccumulable.

Definition at line 242 of file G4AccUnorderedMap.hh.

242{ return G4AccType::kUnorderedMap; }

Referenced by GetType().

◆ GetUnorderedMap() [1/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::unordered_map< Key, T, Hash, KeyEqual, Allocator > & G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::GetUnorderedMap ( )
inline

Definition at line 243 of file G4AccUnorderedMap.hh.

243{ return fUMap; }

◆ GetUnorderedMap() [2/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
const std::unordered_map< Key, T, Hash, KeyEqual, Allocator > & G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::GetUnorderedMap ( ) const
inline

Definition at line 244 of file G4AccUnorderedMap.hh.

244{ return fUMap; }

◆ insert() [1/3]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::pair< typename std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator, bool > G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::insert ( const T & value)
inline

Definition at line 226 of file G4AccUnorderedMap.hh.

226{ return fUMap.insert(value); }

◆ insert() [2/3]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<class P>
std::pair< typename std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator, bool > G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::insert ( P && value)
inline

Definition at line 228 of file G4AccUnorderedMap.hh.

228{ return fUMap.insert(std::move(value)); }

◆ insert() [3/3]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::pair< typename std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::iterator, bool > G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::insert ( T && value)
inline

Definition at line 229 of file G4AccUnorderedMap.hh.

229{ return fUMap.insert(std::move(value)); }

◆ Merge()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
void G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::Merge ( const G4VAccumulable & other)
finalvirtual

Implements G4VAccumulable.

◆ operator[]() [1/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
T & G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::operator[] ( const Key & key)
inline

Definition at line 208 of file G4AccUnorderedMap.hh.

208{ return fUMap[key]; }

◆ operator[]() [2/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
T & G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::operator[] ( Key && key)
inline

Definition at line 209 of file G4AccUnorderedMap.hh.

209{ return fUMap[std::move(key)]; }

◆ Print()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
void G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::Print ( G4PrintOptions options = G4PrintOptions()) const
finalvirtual

Reimplemented from G4VAccumulable.

Referenced by Print().

◆ Reset()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
void G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::Reset ( )
finalvirtual

Implements G4VAccumulable.

◆ SetInitValue()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
void G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::SetInitValue ( const T & value)

Referenced by SetInitValue().

◆ SetMergeMode()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
void G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::SetMergeMode ( G4MergeMode value)
finalvirtual

Reimplemented from G4VAccumulable.

Referenced by SetMergeMode().

◆ size()

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::unordered_map< Key, T, Hash, KeyEqual, Allocator >::size_type G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator >::size ( ) const
inline

Definition at line 214 of file G4AccUnorderedMap.hh.

214{ return fUMap.size(); }
The documentation for this class was generated from the following files: