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-2020 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 "AthenaKernel/tools/type_tools.h"
#include "AthenaKernel/DataObjectSharedPtr.h"
#include "GaudiKernel/DataObject.h"
 
#ifndef NDEBUG
#  include "AthenaKernel/getMessageSvc.h"
#  include "GaudiKernel/MsgStream.h"
#endif
 
#include <type_traits>
#include "boost/mpl/identity.hpp"
#include "boost/mpl/eval_if.hpp"
#include <memory>
#include <type_traits>
 
 
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,
                     IRegisterTransient* irt = 0,
                     bool isConst = true);
 
 
  void* Storable_cast(DataObject* pDObj, CLID clid,
                      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).
    typedef typename SG::BaseType<typename SG::Bases<T>::bases::Base1>::type base1;
 
    // Test to see if it's valid.
    typedef typename std::is_same<base1, SG::NoBase>::type has_base;
 
    // This is what we'll return in the default (no base) case.
    typedef boost::mpl::identity<SG::DataBucket<U> > deflt;
 
    // This is what we use to recursively check the base
    typedef DataBucketTrait<base1, U> recurse;
 
    // Calculate the output.
    // (Note that it's important to use @c eval_if here; otherwise,
    // applying this to @c SG::NoBase won't work.)
    typedef typename boost::mpl::eval_if<has_base, deflt, recurse>::type 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));
  }  
 
  template <typename T>
  DataObject* asStorable(SG::DataObjectSharedPtr<T> pObject) {
    typedef typename DataBucketTrait<T>::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
#ifndef NDEBUG
                     quiet
#endif
                     , IRegisterTransient* irt,
                     bool isConst /*= true*/)
  {
    typedef typename std::remove_const<T>::type T_nc;
    DataBucketTrait<T_nc>::init();
 
    //check inputs
    if (0 == pDObj) {
      pTrans=0;
#ifndef NDEBUG
      MsgStream gLog(Athena::getMessageSvc(), "SG::fromStorable");
      gLog << MSG::WARNING << "null input pointer " << endmsg;
#endif
      return false;
    }
 
    // get T* from DataBucket:
    // All objects in the event store nowadays are instances
    // of DataBucket, so just do a static_cast.
    DataBucketBase* b = static_cast<DataBucketBase*>(pDObj);
    pTrans = b->template cast<T_nc> (irt, isConst);
    bool success = pTrans != nullptr;
 
#ifndef NDEBUG
    if (!quiet && !success) {
      MsgStream gLog(Athena::getMessageSvc(), "SG::fromStorable");
      gLog << MSG::WARNING 
        << "can't convert stored DataObject " << pDObj 
        << " to type ("
        << ClassID_traits<T_nc>::typeName() 
        << ")\n Unless you are following a symlink,"
            << " it probably means you have a duplicate "
        << "CLID = "  << pDObj->clID() 
        << endmsg;
    }
#endif
    return success;
  }
}
 
#endif // ATHENAKERNEL_STORABLECONVERSIONS_H