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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ 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.

{ return fUMap.size(); }

---

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

• G4AccumulableManager.hh
• G4AccUnorderedMap.hh