DataObjectHandle.h

Go to the documentation of this file.

#ifndef GAUDIHIVE_DATAOBJECTHANDLE_H
#define GAUDIHIVE_DATAOBJECTHANDLE_H

#include "GaudiKernel/DataObjectHandleBase.h"
#include "GaudiKernel/ServiceLocatorHelper.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/Property.h"
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/AlgTool.h"

#include <type_traits>

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------


template<typename T>
class DataObjectHandle : public DataObjectHandleBase {
public:
  using DataObjectHandleBase::DataObjectHandleBase;

  T* get() const { return get(true); }

  T* getIfExists() const { return get(false); }

  bool exist() const { return get(false) != nullptr; }

  T* getOrCreate();

  T* put (T* object);

private:

  T* get(bool mustExist) const;
  mutable bool  m_goodType = false;

};

template<typename T>
struct DataObjectReadHandle : public DataObjectHandle<T> {
  DataObjectReadHandle(const DataObjID& k, IDataHandleHolder* owner):
    DataObjectHandle<T>{k, Gaudi::DataHandle::Reader, owner} {}
  DataObjectReadHandle(const std::string& k, IDataHandleHolder* owner):
    DataObjectReadHandle{DataObjID{k}, owner} {}

  DataObjectReadHandle(const DataObjectReadHandle&) = delete;
  DataObjectReadHandle(DataObjectReadHandle&&) = default;

  template <class OWNER, class K,
            typename = typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type>
  inline DataObjectReadHandle( OWNER* owner,
                               std::string name, const K& key = {}, std::string doc = "" )
      : DataObjectHandle<T>( owner, Gaudi::DataHandle::Reader, std::move(name), key, std::move(doc) ) {}
};
template<typename T>
struct DataObjectWriteHandle : public DataObjectHandle<T> {
  DataObjectWriteHandle(const DataObjID& k, IDataHandleHolder* owner):
    DataObjectHandle<T>{k, Gaudi::DataHandle::Writer, owner} {}
  DataObjectWriteHandle(const std::string& k, IDataHandleHolder* owner):
    DataObjectWriteHandle{DataObjID{k}, owner} {}

  DataObjectWriteHandle(const DataObjectWriteHandle&) = delete;
  DataObjectWriteHandle(DataObjectWriteHandle&&) = default;

  template <class OWNER, class K,
            typename = typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type>
  inline DataObjectWriteHandle( OWNER* owner,
                                std::string name, const K& key = {}, std::string doc = "" )
      : DataObjectHandle<T>( owner, Gaudi::DataHandle::Writer, std::move(name), key, std::move(doc) ) {}
};

//---------------------------------------------------------------------------
//
template<typename T>
T* DataObjectHandle<T>::get(bool mustExist) const {

  auto dataObj = fetch();

  if (UNLIKELY(!dataObj) ) {
    if (mustExist) { // Problems in getting from the store
        throw GaudiException("Cannot retrieve " + objKey() +
                             " from transient store.",
                             m_owner ? owner()->name() : "no owner",
                             StatusCode::FAILURE);
    }
    return nullptr;
  }

  if (UNLIKELY(!m_goodType)) { // Check type compatibility once

    T* obj = dynamic_cast<T*>(dataObj);
    m_goodType = ( obj!=nullptr );

    if (UNLIKELY(!m_goodType)) {

      std::string errorMsg("The type provided for "+ objKey()
                           + " is " + System::typeinfoName(typeid(T))
                           + " and is different from the one of the object in the store.");
      //log << MSG::ERROR << errorMsg << endmsg;
      throw GaudiException (errorMsg,"Wrong DataObjectType",StatusCode::FAILURE);
    }
    //log << MSG::DEBUG <<  "The data type (" <<  typeid(T).name()
    //    << ") specified for the handle of " << dataProductName()
    //    << " is the same of the object in the store. "
    //    << "From now on the result of a static_cast will be returned." << endmsg;
    return obj;
  }

  //  setRead();
  // From the second read on, this is safe
  return static_cast<T*> (dataObj);
}

//---------------------------------------------------------------------------
template<typename T>
T* DataObjectHandle<T>::put (T *objectp){
  assert(m_init);
  StatusCode rc = m_EDS->registerObject(objKey(), objectp);
  if (!rc.isSuccess()) {
    throw GaudiException("Error in put of " + objKey(),
                         "DataObjectHandle<T>::put",
                         StatusCode::FAILURE);
  }
  return objectp;
}

//---------------------------------------------------------------------------
template<typename T>
T* DataObjectHandle<T>::getOrCreate (){

    //this process needs to be locking for multi-threaded applications
    //lock(); --> done in caller

    T* obj = get(false);

    //object exists, we are done
    if(obj){
        //unlock();
        return obj;
    }

    //create it
    return put(new T{});

    //unlock();
}


#endif