---

DbHandle.h

Go to the documentation of this file.

//====================================================================
//      DbHandle and related class definitions
//--------------------------------------------------------------------
//
//      Package  : DbCnv ( The LHCb Offline System)
//      Author   : M.Frank
//====================================================================
#ifndef DBCNV_DBHANDLE_H
#define DBCNV_DBHANDLE_H 1

// Forward declarations
class PersistentObject;
class DbContainer;
class DbTypeInfo;
class DbObject;
class DbLink;
template <class T> class dbHandle;
template <class T> class dbObjectHandle;

// Framework include files
#include "GaudiDb/DbBase.h"
#ifndef DBCNV_DBOBJECT_H
#include "GaudiDb/DbObject.h"
#endif
#include "GaudiKernel/GenericLink.h"

// STL include files
#include <string>

class DbObjectAccessor  {
private:
protected:
  void switchPtr(unsigned char* type, DbObject*& from, DbObject* to);
public:
  DbObjectAccessor();
  virtual ~DbObjectAccessor();
  DbResult open(dbObjectHandle<DbObject>& objH, dbHandle<DbContainer>& cntH, const dbHandle<DbLink>& linkH, DbAccessMode mode = DbOOMs::READ);
  DbResult validateAssoc(const DbObject* objP, unsigned char typ,
         const dbHandle<DbLink>& lnk,std::string& fname,std::string& cname,std::string& oname);
  dbHandle<DbContainer>& containedIn(const DbObject* objP) const;
  static dbHandle<DbContainer>* getCntHdl(const DbObject* objP);
};
//##############################################################################

template <class UserClass> class dbObjectHandle          
  : public dbHandleBase< UserClass >,           
    public DbObjectAccessor             
{                       
  friend DbContainer;             
  friend dbHandle<DbObject>;            
  friend dbHandle<DbContainer>;           
protected:                    
  void setType(unsigned char type) const  {
    m_type = type;
  }
  void setObject(const DbObject* obj)   {
    try {                   
      DbObjectAccessor::switchPtr(&m_type,(DbObject*&)m_ptr,(DbObject*)obj);
    }                     
    catch(...)  {                 
      printf("Illegal assignment to  dbHandle < UserClass >\n");  
      DbObjectAccessor::switchPtr(&m_type, (DbObject*&)m_ptr, 0); 
    }                     
  }                     
public:                     
  virtual ~dbObjectHandle()   {
    setObject(0);                 
  }
  dbObjectHandle()  {
  }
  dbObjectHandle(unsigned short typ)  {
    setType(typ);
  }
  template <class T> dbObjectHandle(const dbObjectHandle<T>& copy)    
  : dbHandleBase<UserClass>(), DbObjectAccessor()
  {
    setObject(dynamic_cast<const UserClass*>(copy.ptr()));           
    setType(copy.type());               
  }
  dbObjectHandle(const dbObjectHandle<UserClass>& copy)    
    : dbHandleBase<UserClass>(), DbObjectAccessor()
  {
    setObject(dynamic_cast<const UserClass*>(copy.ptr()));           
    setType(copy.type());               
  }
  template <class T> dbObjectHandle<UserClass>& operator=(const dbObjectHandle<T>& copy)
  {
    setObject(dynamic_cast<const UserClass*>(copy.ptr()));
    setType(copy.type());
    return *this;
  }
  dbObjectHandle<UserClass>& operator=(const dbObjectHandle<UserClass>& copy)    {
    setObject(copy.ptr());
    setType(copy.type());
    return *this;
  }
  bool operator==(const dbObjectHandle<DbObject>& copy)   const  {
    return m_type == copy.m_type && m_ptr == copy.m_ptr;
  }
  long addRef()  {
    if ( m_ptr )  {
      return m_ptr->addRef();
    }
    return -1;
  }
  long release()  {
    if ( m_ptr )  {
      return m_ptr->release();
    }
    return -1;
  }
  dbHandle<DbContainer>& containedIn() const    {
    return DbObjectAccessor::containedIn(m_ptr);
  }
  DbResult validateAssoc(const dbHandle<DbLink>& lnk,std::string& fname,std::string& cname,std::string& oname)    {
    return DbObjectAccessor::validateAssoc(m_ptr, m_type, lnk, fname, cname, oname);
  }
  DbResult open(dbHandle<DbContainer>& cntH,const dbHandle<DbLink>& linkH,DbAccessMode mode = DbOOMs::READ)   {
    if ( m_ptr == 0 )    {
      dbObjectHandle<DbObject> objH(type());
      DbResult status = DbObjectAccessor::open(objH,cntH,linkH,mode);
      setObject(dynamic_cast<const UserClass*>(objH.ptr()));
      return status;
    }                     
    return DbOOMs::DbSuccess;             
  }                     
};

template <class UserClass> class dbHandle
  : public dbObjectHandle< UserClass >
{                       
  friend DbContainer;             
  friend dbHandle<DbObject>;            
  friend dbHandle<DbContainer>;           
protected:                    
public:                     
  virtual ~dbHandle()   {
  }
  dbHandle()    {
  }
  dbHandle(unsigned char typ)
  : dbObjectHandle<UserClass>()
  {
    setType(typ);                 
  }
  dbHandle(const DbObject* obj)
  : dbObjectHandle<UserClass>()
  {
    setObject(dynamic_cast<const UserClass*>(obj));                 
  }
  dbHandle(const UserClass* obj)
  : dbObjectHandle<UserClass>()
  {
    setObject(obj);
  }
  template <class T> dbHandle(const dbObjectHandle<T>& copy)
  : dbObjectHandle<UserClass>()
  {
    setObject(dynamic_cast<const UserClass*>(copy.ptr()));           
    setType(copy.type());               
  }
  dbHandle(const dbObjectHandle<UserClass>& copy) 
  : dbObjectHandle<UserClass>()
  {
    setObject(copy.ptr());           
    setType(copy.type());               
  }
  template <class T> dbHandle<UserClass>& operator=(const dbObjectHandle<T>& copy)    {
    const UserClass* p = dynamic_cast<const UserClass*>(copy.ptr());
    setObject(p);
    setType(copy.type());
    return *this;
  }
  dbHandle<UserClass>& operator=(const dbObjectHandle<UserClass>& copy)    {
    setObject(copy.ptr());
    setType(copy.type());
    return *this;
  }
  operator dbObjectHandle<DbObject>()   {
    dbObjectHandle<DbObject> handle;
    handle.setObject(dynamic_cast<const DbObject*>(m_ptr));
    handle.setType(m_type);
    return handle;
  }
  operator const dbObjectHandle<DbObject>()   const   {
    dbObjectHandle<DbObject> handle;
    handle.setObject(dynamic_cast<const DbObject*>(m_ptr));
    handle.setType(m_type);
    return handle;
  }
};

template <> class dbHandle<DbObject> : public dbObjectHandle<DbObject>    {
  // Friend declarations
  friend DbContainer;
public:
  dbHandle()  {
  }
  dbHandle(unsigned char type)  {
    setType(type);
  }
  virtual ~dbHandle()  {
    setObject(0);
  }
  dbHandle(DbObject* obj) {
    setObject(obj);
  }
  dbHandle(DbObject* obj, unsigned char type) {
    setType(type);
    setObject(obj);
  }
  template <class T> dbHandle(const dbHandle<T>& copy)
  : dbObjectHandle<DbObject>()
  {
    setObject(dynamic_cast<const DbObject*>(copy.ptr()));
    setType(copy.type());
  }
  dbHandle(const dbHandle<DbObject>& copy)
  : dbObjectHandle<DbObject>()
  {
    setObject(copy.ptr());
    setType(copy.type());
  }
  template <class T> dbHandle<DbObject>& operator=(const dbObjectHandle<T>& copy)    {
    setObject(dynamic_cast<const DbObject*>(copy.ptr()));
    setType(copy.type());
    return *this;
  }
  dbHandle<DbObject>& operator=(const dbObjectHandle<DbObject>& copy)    {
    setObject(copy.ptr());
    setType(copy.type());
    return *this;
  }
  DbResult prepare(const dbObjectHandle<DbObject>& objH, dbHandle<DbLink>& linkH, GenericLinkBase::GENERIC& gene);
};


inline 
DbObjectAccessor::DbObjectAccessor()  {
}

inline 
DbObjectAccessor::~DbObjectAccessor()  {
}

inline
void DbObjectAccessor::switchPtr(unsigned char* pType, DbObject*& from, DbObject* to)  {
  try {
    DbObject* ptr = from;
    from = to;
    if ( from )  {
      from->addRef();
      *pType = from->storageType();
    }
    if ( ptr )  {
    ptr->release();
    }
  }
  catch(...)  {
    DbObject::badAssignMessage();
    from = 0;
  }
}
#endif  // DBCNV_DBHANDLE_H

---