DbDatabase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//  DbDatabase and related class definitions
//--------------------------------------------------------------------
//
//  Package    : StorageSvc  (The POOL project)
//  @author      M.Frank
//====================================================================
#ifndef POOL_DBDATABASE_H
#define POOL_DBDATABASE_H
 
// Framework include files
#include "PersistentDataModel/Token.h"
#include "DataModelRoot/RootType.h"
#include "StorageSvc/pool.h"
#include "StorageSvc/DbHandleBase.h"
#include "StorageSvc/Transaction.h"
 
// STL include files
#include <vector>
#include <string>
#include <map>
 
class StatusCode;
 
/*
 *  POOL namespace declaration
 */
namespace pool  {
 
  // Forward declarations
  class IOODatabase;
  class IDbDatabase;
  class IDbContainer;
  class DbDomain;
  class DbDatabase;
  class DbDatabaseObj;
  class DbContainer;
  class DbContainerObj;
  class DbOption;
  class DbTypeInfo;
  typedef const class Shape        *ShapeH;

  class DbDatabase : public DbHandleBase<DbDatabaseObj> {
  protected:
    typedef std::pair<std::string, std::string> Parameter;
    typedef std::vector< Parameter >            Parameters;

    void switchPtr(DbDatabaseObj* obj);
  public:
    explicit DbDatabase(const DbType& typ=POOL_StorageType) { m_type = typ;        }
    DbDatabase(const DbDatabase& cp) : Base()   { switchPtr(cp.m_ptr);    }
    DbDatabase(DbDatabaseObj* obj)              { switchPtr(obj);         }
    virtual ~DbDatabase()                       { switchPtr(0);           }
    DbDatabase& operator=(const DbDatabase& copy) {
      if ( &copy != this )  {
        m_type = copy.m_type;
        switchPtr( copy.m_ptr );
      }
      return *this;
    }

    DbDatabase& operator=(const int /* nuller */ )    {
      switchPtr(0);
      return *this;
    }
 
    // Move
    DbDatabase (DbDatabase&& cp)
    {
      setPtr (cp.m_ptr);
      setType (cp.m_type);
      cp.setPtr (nullptr);
      cp.setType(DbType(0));
    }
    DbDatabase& operator= (DbDatabase&& cp)
    {
      if (&cp != this) {
        switchPtr (nullptr);
        setPtr (cp.m_ptr);
        setType (cp.m_type);
        cp.setPtr (nullptr);
        cp.setType(DbType(0));
      }
      return *this;
    }

    int refCount()  const;
    DbAccessMode openMode() const;
    const std::string& name() const;
    void setName(const std::string& nam);
    const std::string& logon() const;
    long long int size();
    IOODatabase* db();
    const IOODatabase* db()   const;
    StatusCode add(const std::string& name, DbContainerObj* cnt);
    StatusCode remove(const DbContainerObj* cnt);
    const DbContainerObj* find(const std::string& nam) const;
    DbContainerObj* find(const std::string& nam);
    const Token* token() const;
    const DbDomain& containedIn()    const;
          DbDomain& containedIn();
    bool exist(DbDomain& domH, const std::string& nam) const;

    StatusCode open(DbDomain&          domH,
                  const std::string& pfn,
                  const std::string& fid,
                  DbAccessMode mode = pool::READ);

    StatusCode reopen(DbAccessMode mode = pool::READ);
    StatusCode close();
    StatusCode retire();
    bool isOpen() const;

    StatusCode transAct(Transaction::Action action);

    StatusCode setOption(const DbOption& refOpt);

    StatusCode getOption(DbOption& refOpt);
    StatusCode addParam(const std::string& nam, const std::string& val);
    int nParam();
    StatusCode param(const std::string& nam, std::string& val);
    StatusCode params(Parameters& vals);

    StatusCode read(const Token& token, ShapeH shape, void** object);
    StatusCode getLink(const Token::OID_t& oid, Token* pTok);
    std::string cntName(Token& token);
    StatusCode makeLink(Token* pToken, Token::OID_t& linkH);
    StatusCode addShape (const DbTypeInfo* pShape);
    const DbTypeInfo* objectShape(const RootType& typeH);
    const DbTypeInfo* objectShape(const Guid& nam);
    const DbTypeInfo* contShape(const std::string& nam);
    const Token* cntToken(const std::string& cntName);
    StatusCode containers(std::vector<const Token*>& conts, bool intern=false);
    StatusCode containers(std::vector<IDbContainer*>& conts, bool intern=false);
    StatusCode associations(std::vector<const Token*>& assocs);
    StatusCode shapes(std::vector<const DbTypeInfo*>& shaps);
    IDbDatabase* info();
    const IDbDatabase* info()  const;
    void setAge(int value);
    int age()  const;
  };
}       // End namespace pool
#endif  // POOL_DBDatabase_H