Gaudi::HandleDetail Namespace Reference

Typedefs
using	DataObjectPtr = std::unique_ptr< DataObject >
template<typename T >
using	DataObjectAndRef = std::pair< DataObjectPtr, const T & >

Functions
template<typename T >
constexpr bool	isDataObject ()
	Tells whether type T is a subclass of DataObject. More...
template<typename T >
constexpr bool	isRange ()
	Tells whether there is a parameter pack U... such as T = Range<U...> More...
template<typename T , ENABLE_IF(isDataObject< T >()&&!isRange< T >()) >
const T &	unwrapDataObject (const DataObject &rawObject)
	T is a subclass of DataObject, and is not a range: we can just cast the pointer provided by the TES as-is. More...
template<typename RangeT , ENABLE_IF(isRange< RangeT >()) >
const RangeT	unwrapDataObject (const DataObject &)
	T is a Range<...>: Either the TES contains a Range to be copied, or a container which must be turned into a range spanning its content. More...
template<typename T >
DataObjectAndRef< T >	wrapDataObject (DataObjectPtr &&ptr)
template<typename T >
DataObjectAndRef< T >	wrapDataObject (DataObject &&data)
template<typename T , ENABLE_IF(!isDataObject< T >()) >
DataObjectAndRef< T >	wrapDataObject (T &&data)

Typedef Documentation

template<typename T >

using Gaudi::HandleDetail::DataObjectAndRef = typedef std::pair<DataObjectPtr, const T&>

Definition at line 108 of file HandleDetail.h.

using Gaudi::HandleDetail::DataObjectPtr = typedef std::unique_ptr<DataObject>

Definition at line 102 of file HandleDetail.h.

Function Documentation

template<typename T >

constexpr bool Gaudi::HandleDetail::isDataObject

(

)

Tells whether type T is a subclass of DataObject.

Definition at line 35 of file HandleDetail.h.

    {
      return std::is_base_of<DataObject, T>::value;
    }

template<typename T >

constexpr bool Gaudi::HandleDetail::isRange

(

)

Tells whether there is a parameter pack U... such as T = Range<U...>

Definition at line 42 of file HandleDetail.h.

    {
      // FIXME: Implement this
      return false;
    }

template<typename T , ENABLE_IF(isDataObject< T >()&&!isRange< T >()) >

const T & Gaudi::HandleDetail::unwrapDataObject

(

const DataObject &

rawObject

)

T is a subclass of DataObject, and is not a range: we can just cast the pointer provided by the TES as-is.

T is not a subclass of DataObject and is not a range.

So it is stored in the TES as an AnyDataWrapper, which we need to un-wrap.

Definition at line 66 of file HandleDetail.h.

    {
      // FIXME: Dynamic casting on every access is expensive, but the only way
      //        to retain type safety if other code is allowed to perform
      //        arbitrary operations on the TES. The more we restrict what
      //        code other than handles is allowed to do with the TES, the
      //        further away from the hot code path we can push these checks.
      return dynamic_cast<const T&>( rawObject );
    }

template<typename RangeT , ENABLE_IF(isRange< RangeT >()) >

const RangeT Gaudi::HandleDetail::unwrapDataObject

(

const DataObject &

)

T is a Range<...>: Either the TES contains a Range to be copied, or a container which must be turned into a range spanning its content.

Definition at line 88 of file HandleDetail.h.

    {
      // FIXME: Now that we know we're dealing with a range, we need to figure
      //        out whether the thing that lies in the event store is a RangeT
      //        or a container of RangeT::underlying.
      //          - If it's a RangeT, decode it as appropriate and copy it
      //          - If it's a container, create a suitable RangeT & return it
      throw std::runtime_error( "Not implemented yet!" );
    }

template<typename T >

DataObjectAndRef<T> Gaudi::HandleDetail::wrapDataObject

(

DataObjectPtr &&

ptr

)

Definition at line 112 of file HandleDetail.h.

    {
      const T& ref = static_cast<const T&>( *ptr );
      return {std::move( ptr ), ref};
    }

template<typename T >

DataObjectAndRef<T> Gaudi::HandleDetail::wrapDataObject

(

DataObject &&

data

)

Definition at line 120 of file HandleDetail.h.

    {
      return wrapDataObject<T>( std::make_unique<T>( static_cast<T&&>( data ) ) );
    }

template<typename T , ENABLE_IF(!isDataObject< T >()) >

DataObjectAndRef<T> Gaudi::HandleDetail::wrapDataObject

(

T &&

data

)

Definition at line 127 of file HandleDetail.h.

    {
      auto     ptr = std::make_unique<AnyDataWrapper<T>>( std::forward<T>( data ) );
      const T& ref = ptr->getData();
      return {std::move( ptr ), ref};
    }