Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
G4THitsMap.hh
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27//
28#ifndef G4THitsMap_h
29#define G4THitsMap_h 1
30
31#include "G4THitsCollection.hh"
32#include "globals.hh"
33
34#include <map>
35#include <unordered_map>
36
37// class description:
38//
39// This is a template class of hits map and parametrized by
40// The concrete class of G4VHit. This is a uniform collection for
41// a particular concrete hit class objects.
42// An intermediate layer class G4HitsMap appeared in this
43// header file is used just for G4Allocator, because G4Allocator
44// cannot be instansiated with a template class. Thus G4HitsMap
45// class MUST NOT be directly used by the user.
46
47template <typename T, typename Map_t = std::map<G4int, T*>>
48class G4VTHitsMap : public G4HitsCollection
49{
50 private:
51 typedef std::multimap<G4int, T*> mmap_t;
52 typedef std::pair<G4int, T*> pair_t;
53 typedef std::unordered_multimap<G4int, T*> uommap_t;
54
55#define is_same_t(_Tp, _Up) std::is_same<_Tp, _Up>::value
56#define is_multimap_t(_Mp) std::is_same<_Mp, mmap_t>::value
57#define is_uommap_t(_Mp) std::is_same<_Mp, uommap_t>::value
58#define is_mmap_t(_Mp) (is_multimap_t(_Mp) || is_uommap_t(_Mp))
59#define is_fundamental_t(_Tp) std::is_fundamental<_Tp>::value
60
61 template <bool _Bp, typename _Tp = void>
62 using enable_if_t = typename std::enable_if<_Bp, _Tp>::type;
63
64 // ensure fundamental types are initialized to zero
65 template <typename U = T, enable_if_t<is_fundamental_t(U), G4int> = 0>
66 T* allocate() const
67 {
68 return new T(0.);
69 }
70 // non-fundamental types should set values to appropriate values
71 // and avoid issues such as:
72 // G4StatDouble stat(0.); stat += 1.0; gives n == 2;
73 template <typename U = T, enable_if_t<!is_fundamental_t(U), G4int> = 0>
74 T* allocate() const
75 {
76 return new T();
77 }
78
79 public:
80 typedef G4VTHitsMap<T, Map_t> this_type;
81 typedef T value_type;
82 typedef Map_t map_type;
83 typedef typename map_type::iterator iterator;
84 typedef typename map_type::const_iterator const_iterator;
85
86 public: // with description
87 // generic constructor
88 G4VTHitsMap();
89 // det + collection description constructor
90 G4VTHitsMap(G4String detName, G4String colNam);
91 // destructor
92 virtual ~G4VTHitsMap();
93 // equivalence operator
94 G4bool operator==(const G4VTHitsMap<T, Map_t>& right) const;
95
96 //------------------------------------------------------------------------//
97 // Generic operator += where add(...) overloads handle various
98 // U and MapU_t types
99 //------------------------------------------------------------------------//
100 template <typename U, typename MapU_t>
101 this_type& operator+=(const G4VTHitsMap<U, MapU_t>& right) const
102 {
103 MapU_t* aHitsMap = right.GetMap();
104 for(auto itr = aHitsMap->begin(); itr != aHitsMap->end(); ++itr)
105 add<U, map_type>(itr->first, *(itr->second));
106 return (this_type&) (*this);
107 }
108 //------------------------------------------------------------------------//
109
110 public: // with description
111 virtual void DrawAllHits();
112 virtual void PrintAllHits();
113 // These two methods invokes Draw() and Print() methods of all of
114 // hit objects stored in this map, respectively.
115
116 public:
117 // Generic iteration
118 inline Map_t* GetContainer() const { return (Map_t*) theCollection; }
119
120 inline typename Map_t::size_type size() { return GetContainer()->size(); }
121
122 inline typename Map_t::size_type GetIndex(iterator itr) { return itr->first; }
123
124 inline typename Map_t::size_type GetIndex(const_iterator itr) const
125 {
126 return itr->first;
127 }
128
129 template <typename MapU_t = Map_t, enable_if_t<!is_mmap_t(MapU_t), G4int> = 0>
130 inline T* GetObject(G4int idx) const
131 {
132 return (GetContainer()->count(idx) != 0) ? (*GetContainer())[idx] : nullptr;
133 }
134
135 template <typename MapU_t = Map_t, enable_if_t<is_mmap_t(MapU_t), G4int> = 0>
136 inline T* GetObject(G4int idx) const
137 {
138 return (GetContainer()->count(idx) != 0) ? GetContainer()->find(idx)->second
139 : nullptr;
140 }
141
142 inline T* GetObject(iterator itr) const { return itr->second; }
143
144 inline const T* GetObject(const_iterator itr) const { return itr->second; }
145
146 iterator begin() { return GetContainer()->begin(); }
147 iterator end() { return GetContainer()->end(); }
148 const_iterator begin() const { return GetContainer()->begin(); }
149 const_iterator end() const { return GetContainer()->end(); }
150 const_iterator cbegin() const { return GetContainer()->cbegin(); }
151 const_iterator cend() const { return GetContainer()->cend(); }
152
153 public: // with description
154 // Returns a pointer to a concrete hit object.
155 inline Map_t* GetMap() const { return (Map_t*) theCollection; }
156 // Overwrite a hit object. Total number of hit objects stored in this
157 // map is returned.
158 inline size_t entries() const { return ((Map_t*) theCollection)->size(); }
159 // Returns the number of hit objects stored in this map
160 inline void clear();
161
162 public:
163 virtual G4VHit* GetHit(size_t) const { return 0; }
164 virtual size_t GetSize() const { return ((Map_t*) theCollection)->size(); }
165
166 public:
167 //------------------------------------------------------------------------//
168 // Add/Insert a hit object. Total number of hit objects stored in this
169 // map is returned.
170 //------------------------------------------------------------------------//
171 // Standard map overload for same type
172 //------------------------------------------------------------------------//
173 // here we don't use allocate() since instances like G4Colour() == white
174 // and += adds to white (not correct)
175 template <typename U = T, typename MapU_t = Map_t,
176 enable_if_t<is_same_t(U, T) && !is_mmap_t(MapU_t), G4int> = 0>
177 size_t add(const G4int& key, U*& aHit) const
178 {
179 map_type* theHitsMap = GetMap();
180 if(theHitsMap->find(key) == theHitsMap->end())
181 theHitsMap->insert(pair_t(key, new T(*aHit)));
182 else
183 *theHitsMap->find(key)->second += *aHit;
184 return theHitsMap->size();
185 }
186 //------------------------------------------------------------------------//
187 // Multimap overload for same type T
188 //------------------------------------------------------------------------//
189 template <typename U = T, typename MapU_t = Map_t,
190 enable_if_t<(is_same_t(U, T) && is_mmap_t(MapU_t)), G4int> = 0>
191 size_t add(const G4int& key, U*& aHit) const
192 {
193 map_type* theHitsMap = GetMap();
194 theHitsMap->insert(pair_t(key, aHit));
195 return theHitsMap->size();
196 }
197 //------------------------------------------------------------------------//
198 // Multimap overload for different types
199 // assumes type T has overload of += operator for U
200 //------------------------------------------------------------------------//
201 template <typename U = T, typename MapU_t = Map_t,
202 enable_if_t<(!is_same_t(U, T) && is_mmap_t(MapU_t)), G4int> = 0>
203 size_t add(const G4int& key, U*& aHit) const
204 {
205 map_type* theHitsMap = GetMap();
206 T* hit = allocate();
207 *hit += *aHit;
208 theHitsMap->insert(pair_t(key, hit));
209 return theHitsMap->size();
210 }
211
212 public:
213 //------------------------------------------------------------------------//
214 // Standard map overload for same type
215 // assumes type T has overload of += operator for U
216 //------------------------------------------------------------------------//
217 // here we don't use allocate() since instances like G4Colour() == white
218 // and += adds to white (not correct)
219 template <typename U = T, typename MapU_t = Map_t,
220 enable_if_t<(is_same_t(U, T) && !is_mmap_t(MapU_t)), G4int> = 0>
221 size_t add(const G4int& key, U& aHit) const
222 {
223 map_type* theHitsMap = GetMap();
224 if(theHitsMap->find(key) == theHitsMap->end())
225 theHitsMap->insert(pair_t(key, new T(aHit)));
226 else
227 *theHitsMap->find(key)->second += aHit;
228 return theHitsMap->size();
229 }
230 //------------------------------------------------------------------------//
231 // Standard map overload for different type
232 // assumes type T has overload of += operator for U
233 //------------------------------------------------------------------------//
234 template <typename U = T, typename MapU_t = Map_t,
235 enable_if_t<(!is_same_t(U, T) && !is_mmap_t(MapU_t)), G4int> = 0>
236 size_t add(const G4int& key, U& aHit) const
237 {
238 map_type* theHitsMap = GetMap();
239 if(theHitsMap->find(key) == theHitsMap->end())
240 theHitsMap->insert(pair_t(key, allocate()));
241 *theHitsMap->find(key)->second += aHit;
242 return theHitsMap->size();
243 }
244 //------------------------------------------------------------------------//
245 // Multimap overload for same type T
246 //------------------------------------------------------------------------//
247 template <typename U = T, typename MapU_t = Map_t,
248 enable_if_t<(is_same_t(U, T) && is_mmap_t(MapU_t)), G4int> = 0>
249 size_t add(const G4int& key, U& aHit) const
250 {
251 map_type* theHitsMap = GetMap();
252 theHitsMap->insert(pair_t(key, new T(aHit)));
253 return theHitsMap->size();
254 }
255 //------------------------------------------------------------------------//
256 // Multimap overload for different types
257 // assumes type T has overload of += operator for U
258 //------------------------------------------------------------------------//
259 template <typename U = T, typename MapU_t = Map_t,
260 enable_if_t<(!is_same_t(U, T) && is_mmap_t(MapU_t)), G4int> = 0>
261 size_t add(const G4int& key, U& aHit) const
262 {
263 map_type* theHitsMap = GetMap();
264 T* hit = allocate();
265 *hit += aHit;
266 theHitsMap->insert(pair_t(key, hit));
267 return theHitsMap->size();
268 }
269 //------------------------------------------------------------------------//
270
271 public:
272 //------------------------------------------------------------------------//
273 // Set a hit object. Total number of hit objects stored in this
274 // map is returned.
275 //------------------------------------------------------------------------//
276 // Standard overload for same type T
277 //------------------------------------------------------------------------//
278 template <typename U = T, typename MapU_t = Map_t,
279 enable_if_t<(is_same_t(U, T) && !is_mmap_t(MapU_t)), G4int> = 0>
280 inline size_t set(const G4int& key, U*& aHit) const
281 {
282 map_type* theHitsMap = GetMap();
283 if(theHitsMap->find(key) != theHitsMap->end())
284 delete theHitsMap->find(key)->second;
285 theHitsMap->find(key)->second = aHit;
286 return theHitsMap->size();
287 }
288 //------------------------------------------------------------------------//
289 // Multimap overload for same type T
290 //------------------------------------------------------------------------//
291 template <typename U = T, typename MapU_t = Map_t,
292 enable_if_t<(is_same_t(U, T) && is_mmap_t(MapU_t)), G4int> = 0>
293 inline size_t set(const G4int& key, U*& aHit) const
294 {
295 map_type* theHitsMap = GetMap();
296 if(theHitsMap->find(key) != theHitsMap->end())
297 theHitsMap->insert(pair_t(key, aHit));
298 else
299 {
300 delete theHitsMap->find(key)->second;
301 theHitsMap->find(key)->second = aHit;
302 }
303 return theHitsMap->size();
304 }
305 //------------------------------------------------------------------------//
306 // Standard map overload for different types
307 //------------------------------------------------------------------------//
308 template <typename U = T, typename MapU_t = Map_t,
309 enable_if_t<(!is_same_t(U, T) && !is_mmap_t(MapU_t)), G4int> = 0>
310 inline size_t set(const G4int& key, U*& aHit) const
311 {
312 map_type* theHitsMap = GetMap();
313 T* hit = nullptr;
314 if(theHitsMap->find(key) == theHitsMap->end())
315 theHitsMap->insert(std::make_pair(key, hit = allocate()));
316 else
317 hit = theHitsMap->find(key)->second;
318 *hit += *aHit;
319 return theHitsMap->size();
320 }
321 //------------------------------------------------------------------------//
322 // Multimap overload for different types
323 //------------------------------------------------------------------------//
324 template <typename U = T, typename MapU_t = Map_t,
325 enable_if_t<(!is_same_t(U, T) && is_mmap_t(MapU_t)), G4int> = 0>
326 inline size_t set(const G4int& key, U*& aHit) const
327 {
328 map_type* theHitsMap = GetMap();
329 T* hit = allocate();
330 *hit += *aHit;
331 if(theHitsMap->find(key) != theHitsMap->end())
332 theHitsMap->insert(pair_t(key, hit));
333 else
334 {
335 delete theHitsMap->find(key)->second;
336 theHitsMap->find(key)->second = hit;
337 }
338 return theHitsMap->size();
339 }
340 //------------------------------------------------------------------------//
341
342 public:
343 //------------------------------------------------------------------------//
344 // Set a hit object. Total number of hit objects stored in this
345 // map is returned.
346 //------------------------------------------------------------------------//
347 // Standard overload for same type T
348 //------------------------------------------------------------------------//
349 template <typename U = T, typename MapU_t = Map_t,
350 enable_if_t<(is_same_t(U, T) && !is_mmap_t(MapU_t)), G4int> = 0>
351 inline size_t set(const G4int& key, U& aHit) const
352 {
353 map_type* theHitsMap = GetMap();
354 T* hit = nullptr;
355 if(theHitsMap->find(key) != theHitsMap->end())
356 hit = theHitsMap->find(key)->second;
357 else
358 theHitsMap->insert(pair_t(key, hit = allocate()));
359 *hit = aHit;
360 return theHitsMap->size();
361 }
362 //------------------------------------------------------------------------//
363 // Multimap overload for same type T
364 //------------------------------------------------------------------------//
365 template <typename U = T, typename MapU_t = Map_t,
366 enable_if_t<(is_same_t(U, T) && is_mmap_t(MapU_t)), G4int> = 0>
367 inline size_t set(const G4int& key, U& aHit) const
368 {
369 map_type* theHitsMap = GetMap();
370 if(theHitsMap->find(key) != theHitsMap->end())
371 *theHitsMap->find(key)->second = aHit;
372 else
373 theHitsMap->insert(pair_t(key, new T(aHit)));
374 return theHitsMap->size();
375 }
376 //------------------------------------------------------------------------//
377 // Standard map overload for different types
378 //------------------------------------------------------------------------//
379 template <typename U = T, typename MapU_t = Map_t,
380 enable_if_t<(!is_same_t(U, T) && !is_mmap_t(MapU_t)), G4int> = 0>
381 inline size_t set(const G4int& key, U& aHit) const
382 {
383 map_type* theHitsMap = GetMap();
384 T* hit = nullptr;
385 if(theHitsMap->find(key) == theHitsMap->end())
386 theHitsMap->insert(std::make_pair(key, hit = allocate()));
387 else
388 hit = theHitsMap->find(key)->second;
389 *hit += aHit;
390 return theHitsMap->size();
391 }
392 //------------------------------------------------------------------------//
393 // Multimap overload for different types
394 //------------------------------------------------------------------------//
395 template <typename U = T, typename MapU_t = Map_t,
396 enable_if_t<(!is_same_t(U, T) && is_mmap_t(MapU_t)), G4int> = 0>
397 inline size_t set(const G4int& key, U& aHit) const
398 {
399 map_type* theHitsMap = GetMap();
400 T* hit = allocate();
401 *hit += aHit;
402 if(theHitsMap->find(key) != theHitsMap->end())
403 *theHitsMap->find(key)->second = *hit;
404 else
405 theHitsMap->insert(pair_t(key, hit));
406 return theHitsMap->size();
407 }
408 //------------------------------------------------------------------------//
409
410 public:
411 //------------------------------------------------------------------------//
412 // Enable bracket operator. Return pointer to data indexed by key or
413 // last occurring instance of pointer to data index by key in the
414 // case of a multimap
415 //------------------------------------------------------------------------//
416 template <typename MapU_t = Map_t, enable_if_t<!is_mmap_t(MapU_t), G4int> = 0>
417 T* operator[](G4int key) const
418 {
419 map_type* theHitsMap = GetMap();
420 if(theHitsMap->find(key) != theHitsMap->end())
421 return theHitsMap->find(key)->second;
422 return nullptr;
423 }
424 //------------------------------------------------------------------------//
425 template <typename MapU_t = Map_t, enable_if_t<is_mmap_t(MapU_t), G4int> = 0>
426 T* operator[](G4int key) const
427 {
428#ifdef G4VERBOSE
429 static bool _first = true;
430 if(_first)
431 {
432 _first = false;
433 G4Exception("G4THitsMap operator[]", "calling [] on multimap",
434 JustWarning, "Returning the last matching entry");
435 }
436#endif
437 map_type* theHitsMap = GetMap();
438 iterator itr = theHitsMap->find(key);
439 if(itr != theHitsMap->end())
440 {
441 std::advance(itr, theHitsMap->count(key) - 1);
442 return itr->second;
443 }
444 return nullptr;
445 }
446 //------------------------------------------------------------------------//
447
448#undef is_same_t
449#undef is_multimap_t
450#undef is_uommap_t
451#undef is_mmap_t
452#undef is_fundamental_t
453};
454
455//============================================================================//
456
457template <typename T, typename Map_t>
458G4VTHitsMap<T, Map_t>::G4VTHitsMap()
459{
460 theCollection = (void*) new Map_t;
461}
462
463//============================================================================//
464
465template <typename T, typename Map_t>
466G4VTHitsMap<T, Map_t>::G4VTHitsMap(G4String detName, G4String colNam)
467 : G4HitsCollection(detName, colNam)
468{
469 theCollection = (void*) new Map_t;
470}
471
472//============================================================================//
473
474template <typename T, typename Map_t>
475G4VTHitsMap<T, Map_t>::~G4VTHitsMap()
476{
477 map_type* theHitsMap = GetMap();
478 for(iterator itr = theHitsMap->begin(); itr != theHitsMap->end(); ++itr)
479 delete itr->second;
480 delete theHitsMap;
481}
482
483//============================================================================//
484
485template <typename T, typename Map_t>
486G4bool G4VTHitsMap<T, Map_t>::operator==(
487 const G4VTHitsMap<T, Map_t>& right) const
488{
489 return (collectionName == right.collectionName);
490}
491
492//============================================================================//
493
494template <typename T, typename Map_t>
495void G4VTHitsMap<T, Map_t>::DrawAllHits()
496{
497 ;
498}
499
500//============================================================================//
501
502template <typename T, typename Map_t>
503void G4VTHitsMap<T, Map_t>::PrintAllHits()
504{
505 G4cout << "G4THitsMap " << SDname << " / " << collectionName << " --- "
506 << entries() << " entries" << G4endl;
507 /*----- commented out for the use-case where <T> cannot be initialized
508 to be zero or does not support += operator.
509 Map_t * theHitsMap = GetMap();
510 typename Map_t::iterator itr = theHitsMap->begin();
511 T sum = 0.;
512 for(; itr != theHitsMap->end(); ++itr) {
513 G4cout << " " << itr->first << " : "
514 << *(itr->second) << G4endl;
515 sum += *(itr->second);
516 }
517 G4cout << " Total : " << sum << G4endl;
518 ----------------------------------------------------------------------*/
519}
520
521//============================================================================//
522
523template <typename T, typename Map_t>
524void G4VTHitsMap<T, Map_t>::clear()
525{
526 Map_t* theHitsMap = GetMap();
527 for(iterator itr = theHitsMap->begin(); itr != theHitsMap->end(); ++itr)
528 delete itr->second;
529 theHitsMap->clear();
530}
531
532//============================================================================//
533// //
534// //
535// Helpers for different map types //
536// //
537// //
538//============================================================================//
539
540template <typename _Tp>
541class G4THitsMap : public G4VTHitsMap<_Tp, std::map<G4int, _Tp*>>
542{
543 public:
544 typedef G4VTHitsMap<_Tp, std::map<G4int, _Tp*>> parent_type;
545
546 public:
547 G4THitsMap()
548 : parent_type()
549 {}
550 G4THitsMap(G4String detName, G4String colName)
551 : parent_type(detName, colName)
552 {}
553
554 using parent_type::operator+=;
555 using parent_type::operator==;
556 using parent_type::operator[];
557 using parent_type::add;
558 using parent_type::begin;
559 using parent_type::cbegin;
560 using parent_type::cend;
561 using parent_type::clear;
562 using parent_type::DrawAllHits;
563 using parent_type::end;
564 using parent_type::entries;
565 using parent_type::GetHit;
566 using parent_type::GetMap;
567 using parent_type::GetSize;
568 using parent_type::PrintAllHits;
569 using parent_type::set;
570};
571
572//============================================================================//
573
574template <typename _Tp>
575class G4THitsMultiMap : public G4VTHitsMap<_Tp, std::multimap<G4int, _Tp*>>
576{
577 public:
578 typedef G4VTHitsMap<_Tp, std::multimap<G4int, _Tp*>> parent_type;
579
580 public:
581 G4THitsMultiMap()
582 : parent_type()
583 {}
584 G4THitsMultiMap(G4String detName, G4String colName)
585 : parent_type(detName, colName)
586 {}
587
588 using parent_type::operator+=;
589 using parent_type::operator==;
590 using parent_type::operator[];
591 using parent_type::add;
592 using parent_type::begin;
593 using parent_type::cbegin;
594 using parent_type::cend;
595 using parent_type::clear;
596 using parent_type::DrawAllHits;
597 using parent_type::end;
598 using parent_type::entries;
599 using parent_type::GetHit;
600 using parent_type::GetMap;
601 using parent_type::GetSize;
602 using parent_type::PrintAllHits;
603 using parent_type::set;
604};
605
606//============================================================================//
607
608template <typename _Tp>
609class G4THitsUnorderedMap
610 : public G4VTHitsMap<_Tp, std::unordered_map<G4int, _Tp*>>
611{
612 public:
613 typedef G4VTHitsMap<_Tp, std::unordered_map<G4int, _Tp*>> parent_type;
614
615 public:
616 G4THitsUnorderedMap()
617 : parent_type()
618 {}
619 G4THitsUnorderedMap(G4String detName, G4String colName)
620 : parent_type(detName, colName)
621 {}
622
623 using parent_type::operator+=;
624 using parent_type::operator==;
625 using parent_type::operator[];
626 using parent_type::add;
627 using parent_type::begin;
628 using parent_type::cbegin;
629 using parent_type::cend;
630 using parent_type::clear;
631 using parent_type::DrawAllHits;
632 using parent_type::end;
633 using parent_type::entries;
634 using parent_type::GetHit;
635 using parent_type::GetMap;
636 using parent_type::GetSize;
637 using parent_type::PrintAllHits;
638 using parent_type::set;
639};
640
641//============================================================================//
642
643template <typename _Tp>
644class G4THitsUnorderedMultiMap
645 : public G4VTHitsMap<_Tp, std::unordered_multimap<G4int, _Tp*>>
646{
647 public:
648 typedef G4VTHitsMap<_Tp, std::unordered_multimap<G4int, _Tp*>> parent_type;
649
650 public:
651 G4THitsUnorderedMultiMap()
652 : parent_type()
653 {}
654 G4THitsUnorderedMultiMap(G4String detName, G4String colName)
655 : parent_type(detName, colName)
656 {}
657
658 using parent_type::operator+=;
659 using parent_type::operator==;
660 using parent_type::operator[];
661 using parent_type::add;
662 using parent_type::begin;
663 using parent_type::cbegin;
664 using parent_type::cend;
665 using parent_type::clear;
666 using parent_type::DrawAllHits;
667 using parent_type::end;
668 using parent_type::entries;
669 using parent_type::GetHit;
670 using parent_type::GetMap;
671 using parent_type::GetSize;
672 using parent_type::PrintAllHits;
673 using parent_type::set;
674};
675
676//============================================================================//
677
678#endif
JustWarning
@ JustWarning
Definition: G4ExceptionSeverity.hh:65
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
is_mmap_t
#define is_mmap_t(_Mp)
Definition: G4THitsMap.hh:58
is_same_t
#define is_same_t(_Tp, _Up)
Definition: G4THitsMap.hh:55
G4bool
bool G4bool
Definition: G4Types.hh:86
G4int
int G4int
Definition: G4Types.hh:85
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
G4THitsMap::parent_type
G4VTHitsMap< _Tp, std::map< G4int, _Tp * > > parent_type
Definition: G4THitsMap.hh:544
G4THitsMap::G4THitsMap
G4THitsMap(G4String detName, G4String colName)
Definition: G4THitsMap.hh:550
G4THitsMultiMap::parent_type
G4VTHitsMap< _Tp, std::multimap< G4int, _Tp * > > parent_type
Definition: G4THitsMap.hh:578
G4THitsMultiMap::G4THitsMultiMap
G4THitsMultiMap(G4String detName, G4String colName)
Definition: G4THitsMap.hh:584
G4THitsUnorderedMap::G4THitsUnorderedMap
G4THitsUnorderedMap(G4String detName, G4String colName)
Definition: G4THitsMap.hh:619
G4THitsUnorderedMap::parent_type
G4VTHitsMap< _Tp, std::unordered_map< G4int, _Tp * > > parent_type
Definition: G4THitsMap.hh:613
G4THitsUnorderedMultiMap::G4THitsUnorderedMultiMap
G4THitsUnorderedMultiMap(G4String detName, G4String colName)
Definition: G4THitsMap.hh:654
G4THitsUnorderedMultiMap::parent_type
G4VTHitsMap< _Tp, std::unordered_multimap< G4int, _Tp * > > parent_type
Definition: G4THitsMap.hh:648
G4VHit
Definition: G4VHit.hh:48
G4VTHitsMap::iterator
map_type::iterator iterator
Definition: G4THitsMap.hh:83
G4VTHitsMap::GetMap
Map_t * GetMap() const
Definition: G4THitsMap.hh:155
G4VTHitsMap::map_type
Map_t map_type
Definition: G4THitsMap.hh:82
G4VTHitsMap::cbegin
const_iterator cbegin() const
Definition: G4THitsMap.hh:150
G4VTHitsMap::operator+=
this_type & operator+=(const G4VTHitsMap< U, MapU_t > &right) const
Definition: G4THitsMap.hh:101
G4VTHitsMap::GetObject
const T * GetObject(const_iterator itr) const
Definition: G4THitsMap.hh:144
G4VTHitsMap::set
size_t set(const G4int &key, U *&aHit) const
Definition: G4THitsMap.hh:280
G4VTHitsMap::GetSize
virtual size_t GetSize() const
Definition: G4THitsMap.hh:164
G4VTHitsMap::PrintAllHits
virtual void PrintAllHits()
Definition: G4THitsMap.hh:503
G4VTHitsMap::operator==
G4bool operator==(const G4VTHitsMap< T, Map_t > &right) const
Definition: G4THitsMap.hh:486
G4VTHitsMap::set
size_t set(const G4int &key, U &aHit) const
Definition: G4THitsMap.hh:351
G4VTHitsMap::GetContainer
Map_t * GetContainer() const
Definition: G4THitsMap.hh:118
G4VTHitsMap::GetIndex
Map_t::size_type GetIndex(iterator itr)
Definition: G4THitsMap.hh:122
G4VTHitsMap::end
const_iterator end() const
Definition: G4THitsMap.hh:149
G4VTHitsMap::DrawAllHits
virtual void DrawAllHits()
Definition: G4THitsMap.hh:495
G4VTHitsMap::entries
size_t entries() const
Definition: G4THitsMap.hh:158
G4VTHitsMap::GetHit
virtual G4VHit * GetHit(size_t) const
Definition: G4THitsMap.hh:163
G4VTHitsMap::end
iterator end()
Definition: G4THitsMap.hh:147
G4VTHitsMap::G4VTHitsMap
G4VTHitsMap(G4String detName, G4String colNam)
Definition: G4THitsMap.hh:466
G4VTHitsMap::const_iterator
map_type::const_iterator const_iterator
Definition: G4THitsMap.hh:84
G4VTHitsMap::size
Map_t::size_type size()
Definition: G4THitsMap.hh:120
G4VTHitsMap::begin
const_iterator begin() const
Definition: G4THitsMap.hh:148
G4VTHitsMap::operator[]
T * operator[](G4int key) const
Definition: G4THitsMap.hh:417
G4VTHitsMap::cend
const_iterator cend() const
Definition: G4THitsMap.hh:151
G4VTHitsMap::GetObject
T * GetObject(iterator itr) const
Definition: G4THitsMap.hh:142
G4VTHitsMap::~G4VTHitsMap
virtual ~G4VTHitsMap()
Definition: G4THitsMap.hh:475
G4VTHitsMap::this_type
G4VTHitsMap< T, Map_t > this_type
Definition: G4THitsMap.hh:80
G4VTHitsMap::clear
void clear()
Definition: G4THitsMap.hh:524
G4VTHitsMap::GetIndex
Map_t::size_type GetIndex(const_iterator itr) const
Definition: G4THitsMap.hh:124
G4VTHitsMap::add
size_t add(const G4int &key, U &aHit) const
Definition: G4THitsMap.hh:221
G4VTHitsMap::begin
iterator begin()
Definition: G4THitsMap.hh:146
G4VTHitsMap::add
size_t add(const G4int &key, U *&aHit) const
Definition: G4THitsMap.hh:177
G4VTHitsMap::GetObject
T * GetObject(G4int idx) const
Definition: G4THitsMap.hh:130