Database/APR/StorageSvc/StorageSvc/pool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//
//  Package    : StorageSvc (The pool framework)
//
//  Description: Management of the object Databases
//
//  @author      M.Frank
//====================================================================
#ifndef POOL_POOL_H
#define POOL_POOL_H 1
 
// Framework include files
#include "StorageSvc/DbStatus.h"
 
// STL include files
#include <string>
#include <utility>
 
/* Turn this switch if it is possible to agree on a common 
 * base class for all persistent objects.
 */
//#define POOL_HAVE_BASE
 
#ifdef POOL_HAVE_BASE
#define POOL_BASE               : public pool::DbObject
#define POOL_BASE1(b1)          POOL_BASE, b1
namespace pool {  class DbObject; }
#else
#define POOL_BASE
#define POOL_BASE1(b1)          : b1
namespace pool {  typedef void DbObject; }
 
#endif
#define POOL_BASE2(b1,b2)       POOL_BASE1(b1), b2
#define POOL_BASE3(b1,b2,b3)    POOL_BASE2(b1,b2), b3
#define POOL_BASE4(b1,b2,b3,b4) POOL_BASE3(b1,b2,b3), b4
 
#define POOL_BEGIN_STATIC_BLOCK(x) namespace { struct __init  {  __init()  {
#define POOL_END_STATIC_BLOCK(x)   }}; static __init _i;} void* __init_##x ()  {return &_i;}
 
namespace pool  {
  // Type defintions and forward declarations
  typedef int                   DbAccessMode;
  typedef std::pair< long long, long long > DbLink;
}
 
/* namespace poolDb
 *
 *  Description:
 *  All specific constants for a storage technology
 *
 *  @author  M.Frank
 *  @version 1.0
 */
namespace pool   {
  class DbInstanceCount;
 
  static const long long int INVALID = ~0x0LL;
 
  enum AccessMode {
    NONE        =  0,
    NOT_OPEN    =  1<<0,
    READ        =  1<<1, 
    UPDATE      =  1<<2, 
    CREATE      =  1<<3, 
    RECREATE    = (1<<4)+(1<<3),
    WRITE       =  1<<3,
    DESTROY     =  1<<5
  };
 
  static const DbStatus Success      (DbStatus::Success);
  static const DbStatus Warning      (DbStatus::Warning);
  static const DbStatus Error        (DbStatus::Error);
  static const DbStatus ConnTimeout  (static_cast<unsigned int>(DbStatus::Error)+2);
 
  void      debugBreak();
 
  void      debugBreak( const std::string& src, 
                        const std::string& msg,
                        bool rethrow=true);
 
  void      debugBreak( const std::string& src, 
                        const std::string& msg,
                        const std::exception& e,
                        bool rethrow=true);
 
  bool      doTrace();
 
  const char* accessMode(pool::DbAccessMode access_mode);
 
  template<class T> inline DbStatus deletePtr(T*& p)  {
    if ( 0 != p )    {
      delete p;
      p = 0;
    }
    return Success;
  }
  template<class T> inline DbStatus releasePtr(T*& p)  {
    if ( 0 != p )    {
      p->release();
      p = 0;
    }
    return Success;
  }
 
  template<class T> inline int decrementPtr(T*& p)  {
    if ( p )    {
      int cnt = p->release();
      if ( 0 >= cnt )  {
        p = 0;
      }
      return cnt;
    }
    return ~0x0;
  }
 
  class RefCounter {
  private: 
    int m_count = 1;
  public:
    RefCounter() {}
    RefCounter( const RefCounter& ) { m_count = 1; }
    // cppcheck-suppress operatorEqVarError; deliberate
    RefCounter& operator= (const RefCounter&) { return *this; }
    int addRef()   { return ++m_count; }
    int subRef()   { return --m_count; }
  };
    
}
#endif  // POOL_POOL_H