DbContainer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//  DbContainer handle definitions
//--------------------------------------------------------------------
//
//  Package    : StorageSvc  (The POOL project)
//  @author      M.Frank
//====================================================================
#ifndef POOL_DBCONTAINER_H
#define POOL_DBCONTAINER_H
 
// Framework include files
#include "PersistentDataModel/Token.h"
#include "StorageSvc/DbObjectHandle.h"
#include "StorageSvc/Transaction.h"
 
#include <cstdint>
 
/*
 * POOL namespace declaration
 */
namespace pool  {
 
  // Forward declarations
  class IDbContainer;
  class DbSelect;
  class DbDatabase;
  class DbTypeInfo;
  class DbContainerObj;
  class DbTransaction;
  class DbOption;
 
  typedef const class Shape        *ShapeH;
 
  class DbContainer : public DbHandleBase<DbContainerObj>  {
  private:
    void switchPtr( DbContainerObj* obj);
    DbStatus _load( DbObjectHandle<DbObject>& objH,
                    const Token::OID_t& linkH,
                    const DbTypeInfo* typ,
                    bool any_next);
    DbStatus _loadNext(DbObjectHandle<DbObject>& objH,
                    Token::OID_t& linkH,
                    const DbTypeInfo* typ);
    DbStatus _save( DbObjectHandle<DbObject>& objH,
                    const DbTypeInfo* typ);
    DbStatus _remove( DbObjectHandle<DbObject>& objH);
 
  public:
    explicit DbContainer(const DbType& typ=POOL_StorageType) { m_type=typ;          }
    DbContainer(const DbContainer& c) : Base()  { switchPtr(c.m_ptr);      }
    DbContainer (DbContainerObj* ptr)           { switchPtr(ptr);          }
    virtual ~DbContainer()                      { switchPtr(0);            }
    DbContainer& operator=(const DbContainer& copy) {
      if ( &copy != this )  {
        m_type = copy.m_type;
        switchPtr( copy.m_ptr );
      }
      return *this;
    }
    DbContainer& operator=(const int /* nuller */ ) {
      switchPtr(0);
      return *this;
    }
    int refCount() const;
    const std::string& name() const;
    DbAccessMode openMode() const;
    uint64_t size();
    DbDatabase& containedIn();
    const IDbContainer* info()  const;
    IDbContainer* info();
    const DbTypeInfo* objectShape(const Guid& nam);
    const Token* token() const;
    DbStatus close();
 
 
    DbStatus open(DbDatabase&        dbH, 
                  const std::string&  nam, 
                  const DbTypeInfo*   typ, 
                  const DbType&       dbtyp,
                  DbAccessMode        mod);
 
 
    DbStatus checkAccess(DbDatabase&        dbH,
                         const std::string& nam,
                         const DbType&      dbtyp);
 
    bool isOpen() const;
    DbStatus transAct(Transaction::Action action);
    DbStatus setOption(const DbOption& refOpt);
    DbStatus getOption(DbOption& refOpt);
 
    DbStatus select(DbSelect& sel);
    DbStatus fetch(DbSelect& sel);
 
    DbStatus allocate(const void* object, ShapeH shape, Token::OID_t& oid);
    DbStatus save(const void* object, ShapeH shape, Token::OID_t& linkH);
    DbStatus load(void** ptr, ShapeH shape, const Token::OID_t& lH);
 
    void* allocate(unsigned long siz, const DbTypeInfo* typ);
    DbStatus free(void* ptr);
    template <class T> DbStatus remove( const DbObjectHandle<T>& objH)
    { DbObjectHandle<DbObject> oH(objH.ptr()); return _remove(oH);           }
    template <class T> DbStatus save( DbObjectHandle<T>& objH,
                                      const DbTypeInfo* typ)    
    { DbObjectHandle<DbObject> oH(objH.ptr()); return _save(oH, typ);        }
    template <class T> DbStatus load( DbObjectHandle<T>& objH,
                                      const Token::OID_t& linkH,
                                      const DbTypeInfo* typ)
    { return _load(objH, linkH, typ, false);                                 }
    template <class T> DbStatus loadNext(DbObjectHandle<T>& objH,
                                         Token::OID_t& linkH,
                                         const DbTypeInfo* typ)
    { return _loadNext(objH, linkH, typ);                                    }
  };
}       // End namespace pool
 
 
// operator new for the creation of objects using clustering hint
inline
void* operator new (size_t size, pool::DbContainer& cntH, const pool::DbTypeInfo* typ) { 
   return cntH.allocate(size, typ);
}
 
// C++ exception enabled compilation needs this delete operator
inline
void operator delete (void *ptr, pool::DbContainer& cntH) {
   cntH.free(ptr);
}
 
#endif  // POOL_DBCONTAINER_H