DbObject.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//  DbObject definition
//--------------------------------------------------------------------
//
//  Package    : (The POOL project)
//
//  Description: Generic persistable object
//
//  @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 "CxxUtils/checker_macros.h"
 
/*
 * POOL namespace declaration
 */
namespace pool  {
  // forward declarations
  class DbObjectAccessor;
  class DbTypeInfo;
  class DbContainer;
  typedef const class Shape *ShapeH;
}
 
#ifdef POOL_HAVE_BASE
 
namespace pool  {
 
  class DbObject    {
  protected:
    virtual ~DbObject();
  public:
    void* operator new(size_t size);
    void operator delete(void* ptr);
    void* operator new(size_t siz, DbContainer& cntH);
    void operator delete(void *ptr, DbContainer& cntH);
    DbObject();
  };
}
#else
 
void* operator new(size_t siz, pool::DbContainer& cntH, const pool::DbTypeInfo* typ);
void* operator new(size_t siz, pool::DbContainer& cntH, const void *ptr, pool::ShapeH shape);
#endif
 
 
namespace pool {
 
  template <class USER> class DbObjectHandle : public DbHandleBase<USER> {
  private:
    typedef DbHandleBase<USER> Base;
    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:
    void _setType(const DbType& type)     { Base::setType(type);       }
    template<class T> void _setObject(T* p)  {
      if ( 0 == Base::ptr() && 0 == p ) return;
      Base::m_ptr =  p;
    }
    void _setObject(const int /* null_obj */ )  { 
      if ( 0 == Base::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 Base::ptr();     }
    operator USER*()                              { return Base::ptr();     }
      DbObjectHandle<USER>& operator=(const int /* nuller */)
    { _setObject(0); return *this;                                          }
      DbObjectHandle<USER>& operator=(const DbObjectHandle& c)
        {
          if (&c != this)
            _set (c.ptr(), c.type());
          return *this;
        }
    template <typename T> bool operator==(const DbHandleBase<T>& objH) const
    { return Base::type() == objH.type() && Base::ptr() == objH.ptr();      }
    const DbContainer& containedIn() const;
    const Token::OID_t& oid() const;
    Token::OID_t& oid();
    DbStatus makeLink ATLAS_NOT_THREAD_SAFE (const Token* pToken, Token::OID_t& linkH) const;
  };
 
 
  template <class USER> class DbHandle : public DbObjectHandle< USER> {
    typedef DbObjectHandle< USER> Handle;
  public:
    virtual ~DbHandle()                           {                         }
    DbHandle()                                    {                         }
    DbHandle(const DbType& typ)                   { Handle::_setType(typ);  }
    DbHandle(USER* obj)                           { Handle::_setObject(obj);}
    template <typename T> DbHandle(const DbObjectHandle<T>& c)
      : DbObjectHandle<USER>()                    
    { Handle::_set(c.ptr(),c.type());                                       }
    DbHandle(const DbHandle<USER>& c) : DbObjectHandle<USER>()
    { Handle::_set(c.ptr(),c.type());                                       }
    DbHandle<USER>& operator=(DbHandle<USER>& c) {
      if ( this != &c ) Handle::_set(c.ptr(),c.type());
      return *this;
    }
    DbHandle<USER>& operator=(USER* obj) {
      if ( Handle::ptr() != obj ) Handle::_setObject(obj);
      return *this;
    }
    template <typename T> 
    DbHandle<USER>& operator=(DbObjectHandle<T>& c) {
      if ( Handle::ptr() != c.ptr() ) Handle::_set(c.ptr(), c.type());
      return *this;
    }
  };
 
#ifndef POOL_HAVE_BASE
  template <> class DbHandle<DbObject>            {};
#endif
}
 
/*
 *
 *  Inline object handle implementation
 *
 */
#include "StorageSvc/DbObjectAccessor.h"
 
namespace pool {
#ifndef __no_inline
 
  template <class T> inline
  const DbContainer& DbObjectHandle<T>::containedIn() const  
  { return DbObjectAccessor::containedIn(Base::ptr());                   }
 
  template <class T> inline
  Token::OID_t& DbObjectHandle<T>::oid()
  { return DbObjectAccessor::objectOid(Base::ptr());                     }
 
  template <class T> inline
  const Token::OID_t& DbObjectHandle<T>::oid() const  
  { return DbObjectAccessor::objectOid(Base::ptr());                     }
 
  template <class T> inline
  DbStatus DbObjectHandle<T>::makeLink ATLAS_NOT_THREAD_SAFE (const Token* pToken, Token::OID_t& linkH) const 
  { return DbObjectAccessor::makeObjectLink(Base::ptr(), pToken, linkH); }
 
#endif
}       // End namespace pool
#endif  // POOL_DBOBJECT_H