DbContainerObj.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//  DbContainerObj class definitions
//--------------------------------------------------------------------
//
//  Package    : StorageSvc  (The POOL project)
//  @author      M.Frank
//====================================================================
#ifndef POOL_DBCONTAINEROBJ_H
#define POOL_DBCONTAINEROBJ_H 1
 
// Framework include files
#include "PersistentDataModel/Token.h"
#include "StorageSvc/DbObject.h"
#include "StorageSvc/DbDatabase.h"
#include "StorageSvc/DbAccessObj.h"
#include "StorageSvc/DbContainer.h"
 
/*
 *  POOL namespace declaration
 */
namespace pool  {
 
  typedef const class Shape        *ShapeH;
 
  struct DbObjectHolder  {
    DbObject* m_obj;
    DbObjectHolder(DbObject* p) : m_obj(p) {}
    int release();
  };
  class DbContainerObj : public  DbAccessObj<DbObject*, DbObjectHolder >  {
  private:
    typedef DbObjectHandle<DbObject> ObjHandle;
 
    IDbContainer*                 m_info;
    const Token*                  m_tokH;
    DbDatabase                    m_dbH;
    bool                          m_isOpen;
 
    bool hasAccess();
  public:
 
    DbContainerObj( DbDatabase&        dbH,
                    const std::string& nam,
                    const DbType&      dbtyp,
                    DbAccessMode       mod);
    virtual ~DbContainerObj();
    const IDbContainer* info()  const       {  return m_info;         }
    IDbContainer* info()                    {  return m_info;         }
    const DbTypeInfo* objectShape(const Guid& nam);
    DbStatus addShape(const DbTypeInfo* typ);
    DbDatabase& database()                  {  return m_dbH;          }
    const Token* token() const              {  return m_tokH;         }
    bool updatesPending() const;
    bool isOpen() const                     {  return m_isOpen;       }
    bool isReadOnly() const      
    { return !(mode()&pool::UPDATE) && !(mode()&pool::CREATE);    }
    void cancelTransaction()                { }
    uint64_t size();
    DbStatus open(const DbTypeInfo* typ);
    DbStatus close();
    DbStatus retire();
    DbStatus transAct(Transaction::Action);
    DbStatus setOption(const DbOption& opt);
    DbStatus getOption(DbOption& refOpt);
 
    DbStatus remove(ObjHandle& objH);
    DbStatus destroy(const Token::OID_t& linkH);
    DbStatus save(DbObjectHandle<DbObject>& objH,
                  const DbTypeInfo* typ);
 
 
 
    void* allocate(unsigned long siz, DbContainer& cntH, ShapeH shape);
 
    DbStatus allocate(DbContainer& cntH, const void* object, ShapeH shape, Token::OID_t& oid);
 
    DbStatus free(void* ptr, DbContainer& cntH);
 
 
    DbStatus save(DbContainer& cntH, const void* object, ShapeH shape, Token::OID_t& linkH);
 
 
    DbStatus update(DbContainer& cntH, const void* object, ShapeH shape, const Token::OID_t& linkH);
 
 
    DbStatus update(DbContainer& cntH, const void* object, ShapeH shape, const DbObjectHandle<DbObject>& objH);
 
    DbStatus load( void** ptr, ShapeH shape, 
                   const Token::OID_t& linkH, 
                   Token::OID_t&       oid,
                   bool          any_next);
 
    DbStatus update(DbSelect& sel);
    DbStatus destroy(DbSelect& sel);
    DbStatus select(DbSelect& sel);
    DbStatus fetch(DbSelect& sel);
  };
}       // End namespace pool
#endif  // POOL_DBCONTAINEROBJ_H