DbAccessObj.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//  DbAccessObj Base class definitions
//--------------------------------------------------------------------
//
//  Package    : StorageSvc  (The POOL project)
//  @author      M.Frank
//====================================================================
#ifndef POOL_DBACCESSOBJ_H
#define POOL_DBACCESSOBJ_H 1
 
// Framework include files
#include "StorageSvc/pool.h"
#include "StorageSvc/DbType.h"
#include "StorageSvc/IOODatabase.h"
#include "GaudiKernel/StatusCode.h"
 
// STL include files
#include <map>
#include <utility>
#include <atomic>
 
// #define DEBUG_REFCOUNTS
#ifdef DEBUG_REFCOUNTS
#  include<iostream>
#endif
 
/* 
 *  POOL namespace declaration
 */
namespace pool    {


class DbAccessObjBase {
  private:
    mutable std::atomic<int> m_refCount;
    Io::IoFlag            m_mode;
    std::string           m_name;
    DbType                m_type;
    IOODatabase*          m_pool;
 
  public:
    DbAccessObjBase(const std::string& n, Io::IoFlag m, const DbType& t, IOODatabase* s=0)
    : m_refCount(0), m_mode(m), m_name(n), m_type(t), m_pool(s)
    { if( m_pool )  m_pool->addRef(); }

    virtual ~DbAccessObjBase()        {      releasePtr( m_pool );    }
    const std::string& name()  const  {      return m_name;           }
    void setName(const std::string& n){      m_name = n;              }
    Io::IoFlag mode()   const         {      return m_mode;           }
    void setMode(Io::IoFlag m)        {      m_mode = m;              }
    // Inline functions
    const DbType& type()  const       {      return m_type;           }
    const IOODatabase* db()   const   {      return m_pool;           }
    IOODatabase* db()                 {      return m_pool;           }
    int refCount()   const            {      return m_refCount;       }
    int addRef() const  {
#ifdef DEBUG_REFCOUNTS
      std::cout << typeid(*this).name() 
                << "  " 
                << m_name 
                << " Refcount:" 
                << m_refCount+1  
                << std::endl;
#endif
      return ++m_refCount;
    }

    int release()  const   {
      int count = --m_refCount;
#ifdef DEBUG_REFCOUNTS
      std::cout << typeid(*this).name() 
                << "  " 
                << m_name 
                << " Refcount:" 
                << count  
                << std::endl;
#endif
      if ( count == 0 )    {
        delete this;
      }
      return count;
    }
  };
 
 
  template <class KEY, class TYPE> class DbAccessObj : public DbAccessObjBase {
  public:
    typedef DbAccessObj< KEY , TYPE >     Base;
    typedef std::map< KEY, TYPE* >        Keys;
    typedef typename Keys::iterator       iterator;
    typedef typename Keys::const_iterator const_iterator;
 
  private:
    Keys                  m_keys;
 
  public:
    using DbAccessObjBase::DbAccessObjBase;

    size_t size()  const    {
      return m_keys.size();
    }

    void clearEntries()   {
      for( const auto & k : m_keys ) k.second->release();
      m_keys.clear();
    }

    const TYPE* find(const KEY& key)  const   {
      const_iterator i = m_keys.find(key);
      return (m_keys.end() == i) ? 0 : (*i).second;
    }

    TYPE* find(const KEY& key)    {
      iterator i = m_keys.find(key);
      return (m_keys.end() == i) ? 0 : (*i).second;
    }

    StatusCode add(const KEY& key, TYPE* val)   {
      iterator i = m_keys.find(key);
      if ( m_keys.end() == i )    {
        m_keys.insert(std::make_pair(key, val));
        val->addRef();
        return StatusCode::SUCCESS;
      }
      return StatusCode::FAILURE;
    }

    StatusCode remove(const TYPE* val)    {
      for (iterator j = m_keys.begin(); j != m_keys.end(); ++j )    {
        if ( (*j).second == val ) {
          TYPE* p = (*j).second;
          m_keys.erase(j);
          p->release();
          return StatusCode::SUCCESS;
        }
      }
      return StatusCode::FAILURE;
    }
    iterator begin()              {      return m_keys.begin();   }
    const_iterator begin()  const {      return m_keys.begin();   }
    iterator end()                {      return m_keys.end();     }
    const_iterator end()  const   {      return m_keys.end();     }
  };
}      // End namespace pool
#endif // POOL_DBACCESSOBJ_H