ExpressionParsing::PlainAccessorFactory Class Reference

#include <PlainAccessor.h>

Inheritance diagram for ExpressionParsing::PlainAccessorFactory:

Collaboration diagram for ExpressionParsing::PlainAccessorFactory:

Classes
class	IKit
class	PlainValueKit
class	StdVectorKit

Public Member Functions
template<typename T, IProxyLoader::VariableType T_variable_type>
void	registerStdVectorKit ()
template<typename T, IProxyLoader::VariableType T_variable_type>
void	registerPlainValueKit ()
	PlainAccessorFactory ()
std::unique_ptr< IAccessor >	createAccessor (const std::any &handle_key) const
bool	registerReadKey (std::unordered_map< std::string, std::any > &read_keys, const std::type_info &the_type, SGxAODProxyLoader::IParentHelper &parent, const std::string &var_name, std::vector< Gaudi::DataHandle * > &new_input_handles, bool verbose=false)

Static Public Member Functions
static void	throwFailedToAddHandle (const std::string &var_name)
template<class T_Cont>
static bool	registerReadKey (std::unordered_map< std::string, std::any > &read_keys, SGxAODProxyLoader::IParentHelper &parent, const std::string &var_name, std::vector< Gaudi::DataHandle * > &new_input_handles, bool verbose)
static PlainAccessorFactory &	instance ()

Private Attributes
std::unordered_map< std::size_t, std::unique_ptr< IKit > >	m_kits

Static Private Attributes
static CxxUtils::CachedUniquePtrT< PlainAccessorFactory > s_instance	ATLAS_THREAD_SAFE

Detailed Description

Definition at line 91 of file PlainAccessor.h.

Constructor & Destructor Documentation

PlainAccessorFactory()

ExpressionParsing::PlainAccessorFactory::PlainAccessorFactory ( )

inline

Definition at line 193 of file PlainAccessor.h.

                             {
         //         registerPlainValueKit<bool,IProxyLoader::VT_INT>();
         registerPlainValueKit<bool,IProxyLoader::VT_INT>();
         registerPlainValueKit<int,IProxyLoader::VT_INT>();
         registerPlainValueKit<unsigned int,IProxyLoader::VT_INT>();
         registerPlainValueKit<float,IProxyLoader::VT_DOUBLE>();
         registerPlainValueKit<double,IProxyLoader::VT_DOUBLE>();
 
         registerStdVectorKit<bool,IProxyLoader::VT_VECINT>();
         registerStdVectorKit<int,IProxyLoader::VT_VECINT>();
         registerStdVectorKit<unsigned int,IProxyLoader::VT_VECINT>();
         registerStdVectorKit<float,IProxyLoader::VT_VECDOUBLE>();
         registerStdVectorKit<double,IProxyLoader::VT_VECDOUBLE>();
      }

Member Function Documentation

createAccessor()

std::unique_ptr< IAccessor > ExpressionParsing::PlainAccessorFactory::createAccessor ( const std::any & handle_key ) const

inline

Definition at line 207 of file PlainAccessor.h.

                                                                               {
         std::unordered_map<std::size_t,std::unique_ptr<IKit> >::const_iterator
            kit_iter=m_kits.find(handle_key.type().hash_code());
         if (kit_iter == m_kits.end()) {
            std::stringstream msg;
            msg << "ExpressionParsing::PlainAccessorFactory: no kit for type " << handle_key.type().name();
            throw std::runtime_error(msg.str());
         }
         return kit_iter->second->createAccessor(handle_key);
      }

instance()

PlainAccessorFactory & ExpressionParsing::Singleton< PlainAccessorFactory >::instance ( )

inlinestaticinherited

Definition at line 90 of file PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/Utils.h.

                                   {
         if (!s_instance) {
            s_instance.set(std::make_unique<T_Derived>());
         }
         return *s_instance;
      }

registerPlainValueKit()

template<typename T, IProxyLoader::VariableType T_variable_type>

void ExpressionParsing::PlainAccessorFactory::registerPlainValueKit ( )

inline

Definition at line 188 of file PlainAccessor.h.

                                   {
         m_kits.insert( std::make_pair(typeid(SG::ReadHandleKey<T>).hash_code(), std::make_unique<PlainValueKit<T,T_variable_type> >()));
         m_kits.insert( std::make_pair(typeid(T).hash_code(), std::make_unique<PlainValueKit<T,T_variable_type> >()));
      }

registerReadKey() [1/2]

bool ExpressionParsing::PlainAccessorFactory::registerReadKey ( std::unordered_map< std::string, std::any > & read_keys, const std::type_info & the_type, SGxAODProxyLoader::IParentHelper & parent, const std::string & var_name, std::vector< Gaudi::DataHandle * > & new_input_handles, bool verbose = false )

inline

Definition at line 217 of file PlainAccessor.h.

                                               {
         std::unordered_map<std::size_t,std::unique_ptr<IKit> >::const_iterator
            kit_iter=m_kits.find(the_type.hash_code());
         if (kit_iter == m_kits.end()) {
            if (verbose) {
               std::cout << "DEBUG PlainAccessorFactory::createReadKey no matching kit for "  << the_type.name() << " " << the_type.hash_code() << std::endl;
               for (const std::pair<const std::size_t,std::unique_ptr<IKit> > &elm : m_kits) {
                  std::cout << "DEBUG PlainAccessorFactory::createReadKey have "  << elm.first << std::endl;
               }
            }
            return false;
         }
         return kit_iter->second->registerReadKey(read_keys, parent, var_name, new_input_handles, verbose);
      }

registerReadKey() [2/2]

template<class T_Cont>

bool ExpressionParsing::PlainAccessorFactory::registerReadKey ( std::unordered_map< std::string, std::any > & read_keys, SGxAODProxyLoader::IParentHelper & parent, const std::string & var_name, std::vector< Gaudi::DataHandle * > & new_input_handles, bool verbose )

inlinestatic

Definition at line 112 of file PlainAccessor.h.

                                                {
         SG::ReadHandleKey< T_Cont > key(var_name);
         const auto &[mapIterator, inserted] = read_keys.try_emplace(var_name, std::move(key));
         if (!inserted) {
            if ( mapIterator->first == var_name
                && mapIterator->second.type().hash_code() == typeid(key).hash_code()) {
               return true;
            }
            PlainAccessorFactory::throwFailedToAddHandle(var_name);
         }
         SG::ReadHandleKey< T_Cont > *key_final( std::any_cast<SG::ReadHandleKey< T_Cont > >( &mapIterator->second));
         if (!key_final) {
            PlainAccessorFactory::throwFailedToAddHandle(var_name);
         }
         if (parent.declare(*key_final).isFailure()) {
            PlainAccessorFactory::throwFailedToAddHandle(var_name);
         }
         if (verbose) dumpDeclare(key_final);
         initializeHandle(key_final, new_input_handles);
         if (verbose) {
            std::cout << "DEBUG PlainAccessorFactory::registerReadKey register read handle key for " << var_name << " [" << typeid(T_Cont).name() << "]."<< std::endl;
         }
         return true;
      }

registerStdVectorKit()

template<typename T, IProxyLoader::VariableType T_variable_type>

void ExpressionParsing::PlainAccessorFactory::registerStdVectorKit ( )

inline

Definition at line 183 of file PlainAccessor.h.

                                  {
         m_kits.insert( std::make_pair(typeid(std::vector<T>).hash_code(), std::make_unique< StdVectorKit<T,T_variable_type> >()));
         m_kits.insert( std::make_pair(typeid(SG::ReadHandleKey<std::vector<T> >).hash_code(), std::make_unique< StdVectorKit<T,T_variable_type> >()));
      }

throwFailedToAddHandle()

void ExpressionParsing::PlainAccessorFactory::throwFailedToAddHandle ( const std::string & var_name )

inlinestatic

Definition at line 105 of file PlainAccessor.h.

                                                                    {
         std::stringstream msg;
         msg << "Failed to add read handle key for " << var_name;
         throw std::runtime_error(msg.str());
      }

Member Data Documentation

ATLAS_THREAD_SAFE

CxxUtils::CachedUniquePtrT<PlainAccessorFactory> s_instance ExpressionParsing::Singleton< PlainAccessorFactory >::ATLAS_THREAD_SAFE

staticprivateinherited

Definition at line 97 of file PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/Utils.h.

m_kits

std::unordered_map<std::size_t,std::unique_ptr<IKit> > ExpressionParsing::PlainAccessorFactory::m_kits

private

Definition at line 237 of file PlainAccessor.h.

---

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

• PlainAccessor.h