StorableConversions.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAKERNEL_STORABLECONVERSIONS_H
# define ATHENAKERNEL_STORABLECONVERSIONS_H
 
#include "AthenaKernel/DataBucket.h"
#include "AthenaKernel/DataBucketTraitFwd.h"
#include "AthenaKernel/ClassID_traits.h"
#include "GaudiKernel/DataObject.h"
 
#include <memory>
#include <type_traits>
#include <typeinfo>
 
 
namespace SG {
 
  // put a dobj pointer in a bucket as appropriate
  template <typename T> 
  DataObject* asStorable(T* pObject);
 
  // get a dobj pointer from a bucket as appropriate
  template <typename T> 
  bool  fromStorable(DataObject* pDObj, T*& pTrans, bool quiet=false,
                     IRegisterTransient* irt = 0,
                     bool isConst = true);
 
  template <typename T>
  T* Storable_cast(DataObject* pDObj, bool quiet=true,
                   IRegisterTransient* irt = 0,
                   bool isConst = true) {
    T* result;
    return  fromStorable(pDObj, result, quiet, irt, isConst) ? result : 0;
  }
 

  void* fromStorable(DataObject* pDObj, CLID clid,
                     const std::type_info* tinfo = nullptr,
                     bool quiet = false,
                     IRegisterTransient* irt = 0,
                     bool isConst = true);
 

  void* Storable_cast(DataObject* pDObj, CLID clid,
                      const std::type_info* tinfo = nullptr,
                      bool quiet = false,
                      IRegisterTransient* irt = 0,
                      bool isConst = true);
}

// implementation details
 
 
namespace SG {
 

  template <class T, class U /* = T*/>
  struct DataBucketTrait
  {
    // The first base of @c T (or @c SG::NoBase).
    using base1 = SG::BaseType_t<typename SG::Bases<T>::bases::Base1>;
 
    // Test to see if it's valid.
    static constexpr bool has_base = std::is_same_v<base1, SG::NoBase>;
 
    // This is what we'll return in the default (no base) case.
    using deflt = std::type_identity<SG::DataBucket<U> >;
 
    // This is what we use to recursively check the base
    using recurse = DataBucketTrait<base1, U>;
 
    // Calculate the output.
    using type = typename std::conditional_t<has_base, deflt, recurse>::type;

    static void init() {}
  };
 
 
  // put a dobj pointer in a bucket as appropriate
  template <typename T>
  DataObject* asStorable(T* pObject) {
    typedef typename DataBucketTrait<T>::type bucket_t;
    return new bucket_t (pObject);
  }  
 
  template <typename T>
  DataObject* asStorable(std::unique_ptr<T> pObject) {
    typedef typename std::remove_const<T>::type T_nc;
    typedef typename DataBucketTrait<T_nc>::type bucket_t;
    return new bucket_t (std::move(pObject));
  }  
 
  // get a dobj pointer from a bucket as appropriate
  //the DataObject must be a DataBucket<DATA>*.
 
  template <typename T>
  bool  fromStorable(DataObject* pDObj, T*& pTrans, 
                     bool quiet,
                     IRegisterTransient* irt,
                     bool isConst /*= true*/)
  {
    typedef typename std::remove_const<T>::type T_nc;
    DataBucketTrait<T_nc>::init();
 
    pTrans = static_cast<T*> (fromStorable (pDObj, ClassID_traits<T_nc>::ID(),
                                            &typeid(T_nc),
                                            quiet, irt, isConst));
    return pTrans != nullptr;
}
 
}
 
#endif // ATHENAKERNEL_STORABLECONVERSIONS_H