DbIter.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
//====================================================================
//  DbIter definition
//--------------------------------------------------------------------
//
//  Package    : StorageSvc (The POOL project)
//
//  Description: Generic persistable object iterator
//
//  @author      M.Frank
//====================================================================
#ifndef POOL_DBITER_H
#define POOL_DBITER_H
 
// Framework include files
#include "StorageSvc/DbObject.h"
#include "StorageSvc/DbContainer.h"
#include "StorageSvc/DbTypeInfo.h"
 
// STL include files
#include <memory>
/*
 *  POOL namespace declaration
 */
namespace pool  {
 
  template <class T> class DbIter   {
    DbContainer       m_cnt;
    DbHandle<T>       m_obj;
    Token             m_token;
    const DbTypeInfo* m_type;
    DbAccessMode      m_mode;
 
  private:
    DbIter(const DbIter& c) : m_obj(c.m_obj), m_token(c.m_token), m_type(c.m_type),
      m_mode(c.m_mode)                        {                           }
    bool operator==(const DbIter<T>& iter)   const 
    {    return m_obj.ptr() == iter.m_obj.ptr();                          }
    DbIter& operator=(const DbIter& copy)     {
      m_cnt     = copy.m_cnt;
      m_obj     = copy.m_obj;
      m_mode    = copy.m_mode;
      m_token   = copy.m_token;
      m_type    = copy.m_type;
      return *this;
    }
  public:
    DbIter(DbAccessMode mode=pool::READ) : m_token(), m_type(0), m_mode(mode) { }
    virtual ~DbIter() { }
    const DbContainer& container() const{    return m_cnt;                    }
    bool isValid()  const               {    return m_obj.isValid();          }
    DbHandle<T>& operator->()           {    return m_obj;                    }
    DbHandle<T>& operator*()            {    return m_obj;                    }
    DbHandle<T>& handle()               {    return m_obj;                    }
    const DbHandle<T>& handle() const   {    return m_obj;                    }
    const T* object()  const            {    return m_obj.ptr();              }
    T* object()                         {    return m_obj.ptr();              }
    const Token* token() const          {    return &m_token;                 }
    DbStatus scan(const DbContainer& cntH, const DbTypeInfo* typ);
    DbStatus next();
  };
 
  template <> class DbIter<DbObject>   {};
 
} // End namespace pool
 
template <class T> inline 
pool::DbStatus pool::DbIter<T>::scan(const DbContainer& cntH, 
                                     const DbTypeInfo* typ) 
{
  if ( cntH.isValid() )   {
    m_type   = typ;
    m_cnt    = cntH;
  }
  m_obj = DbHandle<T>(cntH.type());
 
  return cntH.isValid()? Success : Error;
}
      
template <class T> inline pool::DbStatus pool::DbIter<T>::next()
{
  DbObjectHandle<DbObject> objH(m_obj.ptr());
  objH._setType(m_obj.type());
  m_token.oid().second++;     // MN: assuming first OID=1?
  if ( m_cnt.loadNext(objH, m_token.oid(), m_type).isSuccess() ) {
    m_obj._setObject(static_cast<T*>(objH.ptr()));
    return Success;
  }
  return Error;
}
 
#endif  // POOL_DBITER_H