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 194 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 208 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()

static 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 189 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 218 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 >

static 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);
         std::pair<std::unordered_map<std::string, std::any >::iterator, bool> ret = read_keys.insert(std::make_pair(var_name, std::move(key)));
         if (!ret.second) {
            if (ret.first != read_keys.end()
                && ret.first->first == var_name
                && ret.first->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 > >( &ret.first->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 184 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()

static 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 238 of file PlainAccessor.h.

---

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

• PlainAccessor.h