---

CdbItr.hh

Go to the documentation of this file.

#ifndef CDB_ITR_HH
#define CDB_ITR_HH

// File and Version Information:
//      $Id: CdbItr.hh,v 1.6 2005/07/26 00:06:25 gapon Exp $

#include "CdbBase/CdbCommon.hh"
#include "CdbBase/CdbIItr.hh"

/// The generic implementation for the public iterators.
/**
  * The class takes the only template parameter: T - a type of the values
  * operated by the iterator.
  *
  * @see CdbIItr
  */
template < typename T >
class CdbItr : public CdbIItr<T> {

private:

  /// The assignment operator (NOT IMPLEMENTED)
  /**
    * This way of initializing the iterator is explicitly prohibited to avoid
    * ambiguity with the regulat assignment operation. That's because C++ doesn't
    * have the "explicit" keyword for assignment operators.
    *
    * Another potential problem of having this form of an assignment operator
    * would be related to potential shared ownership conflicts. If, for example,
    * there is a concrete derived class, and we're assigning one variable of that
    * class a value of the same class then the assignee would never know if
    * the "rhs" value should be taken over or if it's a temporary one. In the second
    * case we'll have the double deletion memory problem.
    *
    * So, let's just stay away of this form of an operator, the explicit class's
    * constructor does all job for us.
    */
    CdbItr& operator=( const CdbIItr<T>* thePtr );

public:

  /// The default constructor.
  /**
    * Leaves the iterator in the invalid state.
    *
    * @see CdbIItr::isValid()
    */
    CdbItr( );

  /// The copy constructor
  /**
    * More details to come...
    */
    CdbItr( const CdbItr<T>& theItr );

  /// The constructor.
  /**
    * Initialize the iterator by a pointer onto a base class's object.
    *
    * NOTE: That we're taking over the ownership of the passed object.
    */
    explicit CdbItr( CdbIItr<T>* thePtr );

  /// The assignment operator
  /**
    * More details to come...
    */
    CdbItr& operator=( const CdbItr<T>& theItr );

  /// The destructor
  /**
    * Details...
    */
    virtual ~CdbItr( );

  /// Reset an iterator to its initial state.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::reset
    * @see CdbStatus
    */
    virtual CdbStatus reset( );

  /// Advance an iterator to the next position.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::next
    */
    virtual bool next( );

  /// Obtain the currently reffered value.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::value
    *
    * @return the current value the iterator is set on
    */
    virtual T value( );

  /// Check if an iterator is valid.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::isValid
    */
    virtual bool isValid( );

  /// Make a clone of itself
  /**
    * @see CdbIItr::clone()
    */
    virtual CdbIItr<T>* clone( ) const;

private:

  /// Set up the internal context
  /**
    * Delete the previously held context and make a new one by cloning
    * the passed object.
    */
    void set( const CdbIItr<T>* thePtr );

private:

  /// This is a pointer onto an object providing the real iterator.

    CdbIItr<T>* _myItr;
};

#ifdef     BABAR_COMP_INST
#include "CdbBase/CdbItr.cc"
#endif  // BABAR_COMP_INST

#endif  // CDB_ITR_HH

---