GetData.h

Go to the documentation of this file.

#ifndef GAUDIUTILS_GETDATA_H
#define GAUDIUTILS_GETDATA_H 1
// ============================================================================
// Include files
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/StatusCode.h"
// ============================================================================
// GaudiUtils
// ============================================================================
#include "GaudiKernel/AnyDataWrapper.h"
#include "GaudiKernel/NamedRange.h"
#include "GaudiKernel/Range.h"
// ============================================================================
// Forward declaration
// ============================================================================
template <class BASE>
class GaudiCommon; // GaudiAlg
// ============================================================================
namespace Gaudi {
  namespace Utils {
    // ========================================================================
    template <class TYPE>
    struct _GetType {
      typedef TYPE* return_type;
    };
    // ========================================================================
    template <class TYPE>
    struct _GetType<TYPE*> {
      typedef TYPE* return_type;
    };
    // ========================================================================
    template <class TYPE>
    struct _GetType<TYPE&> {
      typedef TYPE* return_type;
    };
    // ========================================================================
    template <class CONTAINER>
    struct _GetType<Gaudi::Range_<CONTAINER>> {
      typedef Gaudi::Range_<CONTAINER> return_type;
    };
    // ========================================================================
    template <class CONTAINER>
    struct _GetType<Gaudi::NamedRange_<CONTAINER>> {
      typedef Gaudi::NamedRange_<CONTAINER> return_type;
    };
    // ========================================================================
    template <class TYPE, std::enable_if_t<!std::is_constructible_v<TYPE>, void*> = nullptr>
    inline typename _GetType<TYPE>::return_type getFromTS( IDataProviderSvc* service, const std::string& location ) {
      DataObject* obj = nullptr;
      // Return the casted pointer if the retrieve was successful or nullptr otherwise.
      StatusCode sc = service->retrieveObject( location, obj );
      if ( sc.isSuccess() ) {
        typename _GetType<TYPE>::return_type tobj = dynamic_cast<typename _GetType<TYPE>::return_type>( obj );
        return tobj;
      } else {
        return nullptr;
      }
    }
    // ========================================================================
    template <class TYPE, std::enable_if_t<std::is_constructible_v<TYPE>, void*> = nullptr>
    inline typename _GetType<TYPE>::return_type getFromTS( IDataProviderSvc* service, const std::string& location ) {
      DataObject* obj = nullptr;
      // Return the casted pointer if the retrieve was successful or nullptr otherwise.
      StatusCode sc = service->retrieveObject( location, obj );
      if ( sc.isSuccess() ) {
        typename _GetType<TYPE>::return_type tobj = dynamic_cast<typename _GetType<TYPE>::return_type>( obj );
        if ( !tobj ) {
          // try with AnyDataWrapper
          AnyDataWrapper<TYPE>* tobj2 = dynamic_cast<AnyDataWrapper<TYPE>*>( obj );
          if ( tobj2 ) { tobj = &( tobj2->getData() ); }
        }
        return tobj;
      } else {
        return nullptr;
      }
    }
    // ========================================================================
    template <class TYPE>
    struct GetData {
    public:
      // ======================================================================
      typedef TYPE Type;
      typedef typename _GetType<Type>::return_type return_type;
      // ======================================================================
    public:
      // ======================================================================
      template <class COMMON>
      inline return_type operator()( const COMMON& common, IDataProviderSvc* service, const std::string& location,
                                     const bool checkData = true ) const {
        // use Data Provider Service
        return_type obj = getFromTS<Type>( service, location );
        if ( checkData ) { // check the data
          common.Assert( obj, "get():: No valid data at '" + location + "'" );
        }
        // debug printout
        if ( common.msgLevel( MSG::DEBUG ) ) {
          common.debug() << "The object of type '" << System::typeinfoName( typeid( obj ) ) << "' "
                         << ( obj ? "has been" : "could not be" ) << " retrieved from TS at address '" << location
                         << "'" << endmsg;
        }
        // return located data
        return obj;
        // ======================================================================
      }
    };
    // ========================================================================
    template <class TYPE>
    struct GetData<Gaudi::Range_<std::vector<const TYPE*>>> {
    public:
      // ======================================================================
      typedef Gaudi::Range_<std::vector<const TYPE*>> Type;
      typedef typename _GetType<Type>::return_type    return_type;
      // ======================================================================
    public:
      // ======================================================================
      template <class COMMON>
      inline return_type operator()( const COMMON& common, IDataProviderSvc* service, const std::string& location,
                                     const bool checkData = true ) const {
        DataObject* object = this->getData( service, location );
        if ( object ) {
          typedef typename TYPE::Selection Selection_;
          const Selection_*                sel = dynamic_cast<Selection_*>( object );
          if ( sel ) {
            if ( common.msgLevel( MSG::DEBUG ) ) {
              common.debug() << "The object of type '" << System::typeinfoName( typeid( *object ) )
                             << "' has been retrieved from TS at address '" << location << "'" << endmsg;
            }
            return make_range( sel );
          }
          typedef typename TYPE::Container Container_;
          const Container_*                cnt = dynamic_cast<Container_*>( object );
          if ( cnt ) {
            if ( common.msgLevel( MSG::DEBUG ) ) {
              common.debug() << "The object of type '" << System::typeinfoName( typeid( *object ) )
                             << "' has been retrieved from TS at address '" << location << "'" << endmsg;
            }
            return make_range( cnt );
          }
          // no valid data
          if ( checkData ) common.Assert( false, "get():: No valid data at '" + location + "'" );
        }
        // no valid data
        if ( checkData ) common.Assert( false, "get():: No data at '" + location + "'" );
        // the fictive return
        return return_type();
      }
      // ======================================================================
    public:
      // ======================================================================
      // create the range from the container
      return_type make_range( const typename TYPE::Container* cnt ) const {
        return 0 == cnt ? return_type() : make_range( cnt->begin(), cnt->end() );
      }
      // create the range from the selection
      return_type make_range( const typename TYPE::Selection* cnt ) const {
        return 0 == cnt ? return_type() : return_type( cnt->begin(), cnt->end() );
      }
      // ======================================================================
      DataObject* getData( IDataProviderSvc* service, const std::string& location ) const {
        SmartDataObjectPtr getter( SmartDataObjectPtr::ObjectLoader::access(), service, nullptr, location );
        return getter.accessData();
      }
      // ======================================================================
    private:
      // ======================================================================
      template <class ITERATOR>
      return_type make_range( ITERATOR first, ITERATOR last ) const {
        auto _begin = reinterpret_cast<typename return_type::const_iterator*>( &first );
        auto _end   = reinterpret_cast<typename return_type::const_iterator*>( &last );
        return return_type( *_begin, *_end );
      }
      // ======================================================================
    };
    // ========================================================================
    template <class TYPE>
    struct GetData<Gaudi::NamedRange_<std::vector<const TYPE*>>> {
    public:
      // ======================================================================
      typedef Gaudi::NamedRange_<std::vector<const TYPE*>> Type;
      typedef typename _GetType<Type>::return_type         return_type;
      // ======================================================================
    public:
      // ======================================================================
      template <class COMMON>
      inline return_type operator()( const COMMON& common, IDataProviderSvc* service, const std::string& location,
                                     const bool checkData = true ) const {
        return return_type( m_range( common, service, location, checkData ), location );
      }
      // ======================================================================
    public:
      // ======================================================================
      // create the range from the container
      return_type make_range( const typename TYPE::Container* cnt ) const {
        if ( !cnt ) { return return_type(); }
        static const std::string s_empty = "";
        const IRegistry*         reg     = cnt->registry();
        return return_type( m_range.make_range( cnt ), reg ? reg->identifier() : s_empty );
      }
      // create the range from the selection
      return_type make_range( const typename TYPE::Selection* cnt ) const {
        if ( !cnt ) { return return_type(); }
        static const std::string s_empty = "";
        const IRegistry*         reg     = cnt->registry();
        return return_type( m_range.make_range( cnt ), reg ? reg->identifier() : s_empty );
      }
      // ======================================================================
      DataObject* getData( IDataProviderSvc* service, const std::string& location ) const {
        return m_range.getData( service, location );
      }
      // ======================================================================
    private:
      GetData<Gaudi::Range_<std::vector<const TYPE*>>> m_range;
      // ======================================================================
    };
    // ========================================================================
    template <class TYPE>
    struct GetData<const TYPE> : public GetData<TYPE> {};
    // ========================================================================
    template <class TYPE>
    struct GetData<TYPE*> : public GetData<TYPE> {};
    // ========================================================================
    template <class TYPE>
    struct GetData<TYPE&> : public GetData<TYPE> {};
    // ========================================================================
    template <class TYPE>
    struct CheckData {
    public:
      // ======================================================================
      inline bool operator()( IDataProviderSvc* service, const std::string& location ) const {
        return getFromTS<TYPE>( service, location );
      }
      // ======================================================================
    };
    // ========================================================================
    template <class TYPE>
    struct CheckData<Gaudi::Range_<std::vector<const TYPE*>>> {
    public:
      // ======================================================================
      inline bool operator()( IDataProviderSvc* service, const std::string& location ) const {
        DataObject* object = this->getData( service, location );
        if ( !object ) { return false; }
        return dynamic_cast<typename TYPE::Selection*>( object ) || dynamic_cast<typename TYPE::Container*>( object );
      }
      // ======================================================================
    protected:
      // ======================================================================
      DataObject* getData( IDataProviderSvc* service, const std::string& location ) const {
        SmartDataObjectPtr getter( SmartDataObjectPtr::ObjectLoader::access(), service, nullptr, location );
        return getter.accessData();
      }
      // ======================================================================
    };
    // ========================================================================
    template <class TYPE>
    struct CheckData<Gaudi::NamedRange_<std::vector<const TYPE*>>>
        : public CheckData<Gaudi::Range_<std::vector<const TYPE*>>> {};
    // ========================================================================
    template <class TYPE>
    struct CheckData<TYPE*> : public CheckData<TYPE> {};
    // ========================================================================
    template <class TYPE>
    struct CheckData<TYPE&> : public CheckData<TYPE> {};
    // ========================================================================
    template <class TYPE>
    struct CheckData<const TYPE> : public CheckData<TYPE> {};
    // ========================================================================
    template <class TYPE, class TYPE2>
    struct GetOrCreateData {
    private:
      // ======================================================================
      typedef GetData<TYPE> Getter; // the actual data getter
      // ======================================================================
    public:
      // ======================================================================
      typedef typename Getter::Type Type;
      typedef typename Getter::return_type return_type;
      // ======================================================================
    public:
      // ======================================================================
      template <class COMMON>
      inline return_type operator()( const COMMON& common, IDataProviderSvc* service, const std::string& location,
                                     const std::string& location2 ) const {
        SmartDataPtr<TYPE> obj( service, location );
        if ( !obj ) {
          auto o = std::make_unique<TYPE2>();
          auto r = o.get();
          common.put( service, std::move( o ), location2 );
          if ( common.msgLevel( MSG::DEBUG ) ) {
            common.debug() << "The object of type '" << System::typeinfoName( typeid( *r ) )
                           << "' has been created from TS at address '" << location2 << "'" << endmsg;
          }
          return r;
        }
        auto ret = obj.ptr();
        common.Assert( !( !ret ), "get():: No valid data at '" + location + "'" );
        if ( common.msgLevel( MSG::DEBUG ) ) {
          common.debug() << "The object of type '" << System::typeinfoName( typeid( *ret ) )
                         << "' has been retrieved from TS at address '" << location << "'" << endmsg;
        }
        // return *VALID* data
        return ret;
        // ====================================================================
      }
    };
    // ========================================================================
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<Gaudi::Range_<std::vector<const TYPE*>>, TYPE2> {
    private:
      // ======================================================================
      typedef Gaudi::Range_<std::vector<const TYPE*>> Range;
      typedef GetData<Range> Getter; //  the actual data getter
      typedef CheckData<Range> Checker; // the actual data checker
      // ======================================================================
    public:
      // ======================================================================
      typedef typename Getter::Type Type;
      typedef typename Getter::return_type return_type;
      // ======================================================================
    public:
      // ======================================================================
      template <class COMMON>
      inline return_type operator()( const COMMON& common, IDataProviderSvc* service, const std::string& location,
                                     const std::string& location2 ) const {
        DataObject* obj = m_getter.getData( service, location );
        if ( !obj ) {
          common.put( service, std::make_unique<TYPE2>(), location2 );
          if ( common.msgLevel( MSG::DEBUG ) ) {
            common.debug() << "The object of type '" << System::typeinfoName( typeid( TYPE2 ) )
                           << "' has been created from TS at address '" << location2 << "'" << endmsg;
          }
        }
        return m_getter( common, service, location );
        // ====================================================================
      }
      // ======================================================================
    private:
      // ======================================================================
      Getter m_getter; // the actual data getter
      // ======================================================================
    };
    // ========================================================================
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<Gaudi::NamedRange_<std::vector<const TYPE*>>, TYPE2> {
    private:
      // ======================================================================
      typedef Gaudi::NamedRange_<std::vector<const TYPE*>> Range;
      typedef Gaudi::Range_<std::vector<const TYPE*>>      Range_;
      typedef GetOrCreateData<Range_, TYPE2>               Helper;
      typedef GetData<Range> Getter; //  the actual data getter
      // ======================================================================
    public:
      // ======================================================================
      typedef typename Getter::Type Type;
      typedef typename Getter::return_type return_type;
      // ======================================================================
    public:
      // ======================================================================
      template <class COMMON>
      inline return_type operator()( const COMMON& common, IDataProviderSvc* service, const std::string& location,
                                     const std::string& location2 ) const {
        return return_type( m_range( common, service, location, location2 ), location );
      }
      // ======================================================================
    private:
      // ======================================================================
      Helper m_range; // the actual data getter
      // ======================================================================
    };
    // ========================================================================
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<TYPE, TYPE2*> : public GetOrCreateData<TYPE, TYPE2> {};
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<TYPE*, TYPE2> : public GetOrCreateData<TYPE, TYPE2> {};
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<TYPE*, TYPE2*> : public GetOrCreateData<TYPE, TYPE2> {};
    // ========================================================================
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<TYPE, const TYPE2> : public GetOrCreateData<TYPE, TYPE2> {};
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<const TYPE, TYPE2> : public GetOrCreateData<TYPE, TYPE2> {};
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<const TYPE, const TYPE2> : public GetOrCreateData<TYPE, TYPE2> {};
    // ========================================================================
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<TYPE, TYPE2&> : public GetOrCreateData<TYPE, TYPE2> {};
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<TYPE&, TYPE2> : public GetOrCreateData<TYPE, TYPE2> {};
    template <class TYPE, class TYPE2>
    struct GetOrCreateData<TYPE&, TYPE2&> : public GetOrCreateData<TYPE, TYPE2> {};
    // ========================================================================
  } // namespace Utils
  // ==========================================================================
} //                                                     end of namespace Gaudi
// ============================================================================
//                                                                      The END
// ============================================================================
#endif // GAUDIUTILS_GETDATA_H