DataBucket.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAKERNEL_DATABUCKET_H
#define ATHENAKERNEL_DATABUCKET_H
 
#include "AthenaKernel/DataBucketBase.h"
#include "AthenaKernel/DataObjectSharedPtr.h"
 
//FIXME CLID is a tdef and can't be forward declared 
#include "GaudiKernel/ClassID.h"
#include <memory>
#include <type_traits>
 
namespace SG { 
  class IRegisterTransient;
  class CopyConversionBase;
 
  template <class T> 
  class DataBucket : public DataBucketBase {
  
  public:
    
    // CONSTRUCTORS:
  
    DataBucket(): m_ptr(0) {}  //needed by the generic converters
    DataBucket(T* data);
    template <class U>
    DataBucket(std::unique_ptr<U> data);
    DataBucket(SG::DataObjectSharedPtr<T> data);
  
    // DESTRUCTOR:
  
    virtual ~DataBucket();
  
    // DATAOBJECT METHODS
    virtual const CLID& clID() const override;
    static const CLID& classID();
 
    // return the pointer as a void*
    virtual void* object() override
    {
      typedef typename std::remove_const<T>::type T_nc;
      return const_cast<T_nc*>(m_ptr);
    }
 
    virtual const std::type_info& tinfo() const override
    {
      return typeid(T);
    }
 
    // Serialize the object for reading
    //  StreamBuffer& serialize(StreamBuffer& s);
    // Serialize the object for writing
    //  StreamBuffer& serialize(StreamBuffer& s)  const;
  
  
 
    // AUTOMATIC CONVERSION OF TYPES
    operator T*()                 { return ptr(); } //FIXME can we do without?
    operator const T*() const     { return cptr(); }
 
    virtual void* cast (CLID clid,
                        IRegisterTransient* irt = 0,
                        bool isConst = true) override;
    
 
    virtual void* cast (const std::type_info& tinfo,
                        IRegisterTransient* irt = 0,
                        bool isConst = true) override;
 
    virtual void* cast (CLID clid,
                        const std::type_info& tinfo,
                        SG::IRegisterTransient* irt = 0,
                        bool isConst = true) override;
 
 
    virtual void relinquish() override{ m_ptr=0;} //LEAKS m_ptr
 
    virtual void lock() override;
 
 
  protected:
    T* ptr() { return m_ptr; }
    const T* cptr() const { return m_ptr; }
 
 
    void* tryStaticConversion (CLID clid);
 
 
    void* tryStaticConversion (const std::type_info& tinfo);
 
 
private:
    T* m_ptr;  //we own the thing now!
 
    typedef std::pair<const CopyConversionBase*, void*> ent_t;
    typedef std::vector<ent_t> vec_t;
    vec_t m_cnvcopies;
 
    DataBucket (const DataBucket&);
    DataBucket& operator= (const DataBucket&);
  };
} //end namespace SG  
#include "AthenaKernel/DataBucket.icc"
 
#endif // ATHENAKERNEL_DATABUCKET_H