DbContainerImp.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//
//  Package    : StorageSvc (The POOL project)
//
//  @author      M.Frank
//====================================================================
#ifndef POOL_DBCONTAINERIMP_H
#define POOL_DBCONTAINERIMP_H 1
 
#include "PersistentDataModel/Token.h"
#include "StorageSvc/IDbContainer.h"
 
// STL include files
#include <map>
#include <vector>
#include <utility>
 
/*
 * POOL namespace declaration
 */
namespace pool    {
 
  // Forward declarations
  class IDbContainer;
 
  class DbContainerImp : virtual public IDbContainer
  {
  protected:
 
    struct DbAction {
      const void*         object;
      const Shape*        shape;
      Token::OID_t        link;
      AccessMode          action;
 
      DbAction() : object(nullptr), shape(nullptr), action(NONE)   { }
      DbAction(const void* obj, const Shape* s, const Token::OID_t&  l, AccessMode a)
            : object(obj), shape(s), link(l), action(a)   { }
 
      const void*       dataAtOffset(size_t offset) {
         return static_cast<const char*>(object) + offset;
      }
    };
    
    typedef std::vector< DbAction > ActionList;
    
  private:
    ActionList            m_stack;
    size_t                m_size;
    size_t                m_writeSize;
    int                   m_stackType;
  protected:
    std::string           m_name;
    bool                  m_canUpdate;
    bool                  m_canDestroy;
 
    virtual ~DbContainerImp();
    int stackType()   const
    { return m_stackType;                                                     }
    size_t stackSize()  const   
    { return m_size;                                                          }
    ActionList::value_type* stackEntry(size_t which) 
    { return (which <= m_size) ? &(*(m_stack.begin()+which)) : 0;             }
    virtual DbStatus writeObject(ActionList::value_type& /* entry */)  
    { return Error;                                                   }
    virtual DbStatus commitTransaction();
 
  public:
    DbContainerImp();
    virtual void release() override                    { delete this;           }
    virtual uint64_t size() override;
    virtual std::string name() const override
    { return m_name; }
    virtual uint64_t nextRecordId() override;
    virtual void useNextRecordId(uint64_t) override {};
    virtual DbStatus close() override;
 
 
    virtual DbStatus getOption(DbOption& opt) override;
 
 
    virtual DbStatus setOption(const DbOption& opt) override;
 
    virtual DbStatus transAct(Transaction::Action) override;
    virtual void* allocate(   unsigned long siz, 
                              DbContainer&  cntH,
                              ShapeH shape) override;
    virtual DbStatus allocate(DbContainer& cntH, 
                              const void* object,
                              ShapeH shape,
                              Token::OID_t& oid) override;
    virtual DbStatus free(    void* ptr,
                              DbContainer& cntH) override;
    virtual DbStatus fetch(DbSelect&      sel) override;
    virtual DbStatus save(  DbObjectHandle<DbObject>& objH) override;
 
 
    virtual DbStatus save(DbContainer&  cntH,
                          const void* object,
                          ShapeH shape,
                          Token::OID_t& linkH) override;
 
 
    virtual DbStatus load( void** ptr, ShapeH shape, 
                           const Token::OID_t& lnkH, 
                           Token::OID_t&       oid,
                           bool                any_next) override;
    virtual DbStatus clearStack();
    virtual DbStatus fetch(const Token::OID_t& linkH, Token::OID_t& stmt);
 
 
    virtual DbStatus loadObject(void** ptr, ShapeH shape, Token::OID_t& oid) = 0;
 
  };
}       // End namespace pool
#endif  // POOL_DBCONTAINERIMP_H