G4Cache< VALTYPE > Class Template Reference

#include <G4Cache.hh>

Inheritance diagram for G4Cache< VALTYPE >:

Public Types
using	value_type = VALTYPE

Public Member Functions
	G4Cache ()
	G4Cache (const value_type &v)
virtual	~G4Cache ()
value_type &	Get () const
void	Put (const value_type &val) const
value_type	Pop ()
	G4Cache (const G4Cache &rhs)
G4Cache &	operator= (const G4Cache &rhs)

Protected Member Functions
const G4int &	GetId () const

Detailed Description

template<class VALTYPE>
class G4Cache< VALTYPE >

Definition at line 88 of file G4Cache.hh.

Member Typedef Documentation

value_type

template<class VALTYPE>

using G4Cache< VALTYPE >::value_type = VALTYPE

Definition at line 91 of file G4Cache.hh.

Constructor & Destructor Documentation

G4Cache() [1/3]

template<class V>

G4Cache< V >::G4Cache

(

)

Definition at line 210 of file G4Cache.hh.

{
  G4AutoLock l(G4TypeMutex<G4Cache<V>>());
  id = instancesctr++;
#ifdef g4cdebug
  std::cout << "G4Cache id: " << id << std::endl;
#endif
}

Referenced by G4Cache(), G4Cache(), operator=(), and ~G4Cache().

G4Cache() [2/3]

template<class VALTYPE>

G4Cache< VALTYPE >::G4Cache

(

const value_type &

v

)

~G4Cache()

template<class V>

G4Cache< V >::~G4Cache ( )

virtual

Definition at line 270 of file G4Cache.hh.

{
#ifdef g4cdebug
  std::cout << "~G4Cache id: " << id << std::endl;
#endif
  // don't automatically lock --> wait until we can catch an error
  // without scoping the G4AutoLock
  //
  G4AutoLock l(G4TypeMutex<G4Cache<V>>(), std::defer_lock);
 
  // sometimes the mutex is unavailable in destructors so
  // try to lock the associated mutex, but catch if it fails
  try
  {
    // a system_error in lock means that the mutex is unavailable
    // we want to throw the error that comes from locking an unavailable
    // mutex so that we know there is a memory leak
    // if the mutex is valid, this will hold until the other thread finishes
    //
    l.lock();
  } catch(std::system_error& e)
  {
    // the error that comes from locking an unavailable mutex
#ifdef G4VERBOSE
    G4cout << "Non-critical error: mutex lock failure in ~G4Cache<"
           << typeid(V).name() << ">. " << G4endl
           << "If the RunManagerKernel has been deleted, it failed to "
           << "delete an allocated resource" << G4endl
           << "and this destructor is being called after the statics "
           << "were destroyed." << G4endl;
    G4cout << "Exception: [code: " << e.code() << "] caught: " << e.what()
           << G4endl;
#endif
  }
  ++dstrctr;
  G4bool last = (dstrctr == instancesctr);
  theCache.Destroy(id, last);
  if(last)
  {
    instancesctr.store(0);
    dstrctr.store(0);
  }
}

G4Cache() [3/3]

template<class VALTYPE>

G4Cache< VALTYPE >::G4Cache

(

const G4Cache< VALTYPE > &

rhs

)

Member Function Documentation

Get()

template<class V>

V & G4Cache< V >::Get ( ) const

inline

Definition at line 315 of file G4Cache.hh.

{
  return GetCache();
}

Referenced by G4MapCache< KEYTYPE, VALTYPE >::Begin(), G4VectorCache< VALTYPE >::Begin(), G4VectorCache< VALTYPE >::Clear(), G4MapCache< KEYTYPE, VALTYPE >::End(), G4VectorCache< VALTYPE >::End(), G4MapCache< KEYTYPE, VALTYPE >::Erase(), G4MapCache< KEYTYPE, VALTYPE >::Find(), G4VectorCache< VALTYPE >::G4VectorCache(), G4MapCache< KEYTYPE, VALTYPE >::Insert(), G4ThreadLocalSingleton< T >::Instance(), G4MapCache< KEYTYPE, VALTYPE >::operator[](), G4VectorCache< VALTYPE >::operator[](), G4VectorCache< VALTYPE >::Pop_back(), G4VectorCache< VALTYPE >::Push_back(), G4MapCache< KEYTYPE, VALTYPE >::Size(), and G4VectorCache< VALTYPE >::Size().

GetId()

template<class VALTYPE>

const G4int & G4Cache< VALTYPE >::GetId ( ) const

inlineprotected

Definition at line 116 of file G4Cache.hh.

{ return id; }

Referenced by G4MapCache< KEYTYPE, VALTYPE >::~G4MapCache().

operator=()

template<class VALTYPE>

G4Cache< V > & G4Cache< V >::operator=

(

const G4Cache< VALTYPE > &

rhs

)

Definition at line 241 of file G4Cache.hh.

{
  if(this == &rhs)
    return *this;
 
  // Force copy of cached data
  //
  V aCopy = rhs.GetCache();
  Put(aCopy);
 
#ifdef g4cdebug
  std::cout << "Assignement operator with id: " << id << std::endl;
#endif
  return *this;
}

Pop()

template<class V>

V G4Cache< V >::Pop ( )

inline

Definition at line 328 of file G4Cache.hh.

{
  return GetCache();
}

Put()

template<class VALTYPE>

void G4Cache< V >::Put ( const value_type & val ) const

inline

Definition at line 321 of file G4Cache.hh.

{
  GetCache() = val;
}

Referenced by G4ThreadLocalSingleton< T >::G4ThreadLocalSingleton(), G4ThreadLocalSingleton< T >::Instance(), and operator=().

---

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

• G4Cache.hh