DbObjectHandle.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//  DbObject definition
//--------------------------------------------------------------------
//
//  Package    : (The POOL project)
//
//  Description: Generic handle to persistable objects
//
//  @author      M.Frank
//====================================================================
#ifndef POOL_DBOBJECT_H
#define POOL_DBOBJECT_H 1
 
// Framework include files
#include "PersistentDataModel/Token.h"
#include "StorageSvc/pool.h"
#include "StorageSvc/DbType.h"
#include "StorageSvc/DbHandleBase.h"
#include "StorageSvc/DbHeap.h"
#include "StorageSvc/DbDatabase.h"
#include "CxxUtils/checker_macros.h"
 
namespace pool {
 
  class DbContainer;
 
  template <class USER> class DbObjectHandle : public DbHandleBase<USER> {
  private:
    using Base = DbHandleBase<USER>;
    const USER* makePtr(void* p)                {  return (const USER*)(p); }
  protected:
    template<typename T> void _set(const T* ptr, const DbType& typ) {
      _setObject(ptr);
      _setType(typ);
    }
  public:
    using Base::ptr;
    using Base::type;
 
    void _setType(const DbType& type)     { Base::setType(type);       }
    template<class T> void _setObject(T* p)  {
      if ( 0 == ptr() && 0 == p ) return;
      Base::m_ptr =  p;
    }
    void _setObject(const int /* null_obj */ )  { 
      if ( 0 == ptr() ) return;
      Base::m_ptr = 0;
    }
  public:
    virtual ~DbObjectHandle()                 { _setObject(0);              }
    DbObjectHandle()                          {                             }
    DbObjectHandle(const DbType& typ)         { _setType(typ);              }
    DbObjectHandle(USER* p)                   { _setObject(p);              }
 
    DbObjectHandle(const DbObjectHandle<USER>& c) : DbHandleBase<USER>()
    { _set(c.ptr(),c.type());                                               }
 
    operator const USER*() const              { return ptr();               }
    operator USER*()                          { return ptr();               }
 
    DbObjectHandle<USER>& operator=(const int /* nuller */)
    { _setObject(0); return *this;                                          }
 
    DbObjectHandle<USER>& operator=(DbObjectHandle& c) {
      if (&c != this)  _set (c.ptr(), c.type());
      return *this;
    }
 
    DbObjectHandle<USER>& operator=(USER* obj) {
      if( ptr() != obj ) _setObject(obj);
      return *this;
    }
 
    template <typename T> bool operator==(const DbHandleBase<T>& objH) const
    { return type() == objH.type() && ptr() == objH.ptr();      }
 
    const DbContainer& containedIn() const
    {  return DbHeap::container(ptr());  }
 
    const Token::OID_t& oid() const
    { return DbHeap::oid(ptr()); }
 
    Token::OID_t& oid()
    { return DbHeap::oid(ptr()); }
 
    DbStatus makeLink ATLAS_NOT_THREAD_SAFE (Token* pToken, Token::OID_t& linkH) const  {
      if( pToken )   {
        DbDatabase& dbH = containedIn().containedIn();
        return dbH.makeLink(pToken, linkH);
      }
      return Error;
    }
  };
 
 
  template <class USER> using DbHandle = DbObjectHandle< USER>;
 
}  // End namespace pool
 
#endif  // POOL_DBOBJECT_H