---

CdbAdapterItr.hh

Go to the documentation of this file.

#ifndef CDBBASE_ADAPTER_ITR_HH
#define CDBBASE_ADAPTER_ITR_HH

// File and Version Information:
//      $Id: CdbAdapterItr.hh,v 1.2 2005/08/26 07:36:47 gapon Exp $

#include "CdbBase/CdbIItr.hh"

/// A proxy class retranslating values of an "input" type into the "output" one
/**
  * This abstract class is meant to be used for rapid building of CDB API iterators
  * of the "output" type out of input iterators of the "input" type of elements.
  * The class is parameterized by two parameters:
  *
  *   T - "output" type of the iterator values produced by the current iterator
  *   I - "input" type of an input iterator's elements
  *
  * A basic idea is that a value of the I type needs to be translated into the corresponding
  * value of the T type. The translation is done through a special virtual method to be
  * overloaded by a subclass.
  *
  * In addition, the iterator provides an optional filtering mechanism to evaluate each input
  * object withing the iterator's "::next()" method. That would allow (if needed by a subclass)
  * to exclude certain objects out of the input sequence from being translated and delivered
  * though the "::value()" and "::toValue()" method. The name of the method is "::isAccepted()".
  * If the method returns "true" then the object is accepted, otherwise - it's rejected,
  * and the iterator will go to the next object input object and so on. By default the method
  * will accept all objects.
  *
  * @see CdbAdapterItr::toValue()
  * @see CdbAdapterItr::isAccepted()
  *
  * EXAMPLE:
  *
  *   #include "CdbBase/CdbAdapterItr.hh"
  *
  *   class MyItr : public CdbAdapterItr<std::string, unsigned int> {
  *   public:
  *       MyItr( const CdbIItr<unsigned int>& theInputItr ) :
  *           CdbAdapterItr<std::string, unsigned int>( theInputItr )
  *       { }
  *   protected:
  *       virtual std::string toValue( const unsigned int& theValue ) const
  *       { ... }
  *       virtual bool isAccepted( const unsigned int& theValue ) const
  *       {
  *         return ( theValue >= 0 );
  *       }
  *   };
  *
  * IMPLEMENTATION NOTE:
  *
  *   This particular implementation of the iterator has not been optimized to cache
  *   the translated values locally. This feature will be implemented later. Just keep
  *   this performance issue in mind when using the iterator.
  */
template< class T,
          class I >
class CdbAdapterItr : public CdbIItr<T> {

private:

  /// The default constructor (NOT IMPLEMENTED)

    CdbAdapterItr( );

  /// The assignment operator (NOT IMPLEMENTED)

    CdbAdapterItr<T,I>& operator=( const CdbAdapterItr<T,I>& theItr );

protected:

  /// The normal constructor
  /**
    * We'll take an input iterator whose values need to be retranslated
    * to deliver values of specified "output" type as the iterator will advance.
    *
    * DESIGN NOTE:
    *
    *   The iterator will take over the specified one.
    */
    CdbAdapterItr( CdbIItr<I>* theInputItrPtr );

  /// The copy constructor

    CdbAdapterItr( const CdbAdapterItr<T,I>& theItr );

public:

  /// The destructor

    virtual ~CdbAdapterItr( );

  /// 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( );

protected:

  /// User defined translation for the currently referred value.
  /**
    * This method is being called by the current implementation of the itarator
    * to translate the desired information out of the currently refered element of
    * the input iterator passed to the class's constructor.
    *
    * The method is supposed to be implemented by a subclass.
    *
    * @return the current value the iterator is set on
    */
    virtual T toValue( const I& ) const = 0;

  /// Optional user defined filter for input objects
  /**
    * This method is being called by the "::next()" method of the current implementation
    * of the itarator for each input object in order to determine if that object needs
    * to be translated or filtered out.
    *
    * If the method returns "true" then the object is accepted, otherwise - it's rejected,
    * and the iterator will go to the next object input object and so on.
    *
    * The default implementation of the method would accept all objects.
    *
    * The method can be optionally implemented by a subclass.
    *
    * @return "true" to accept an object, and "false" - to reject.
    */
    virtual bool isAccepted( const I& ) const { return true; }

private:

    CdbIItr<I>* _myInputItrPtr;
};

#ifdef    BABAR_COMP_INST
#include "CdbBase/CdbAdapterItr.cc"
#endif /* BABAR_COMP_INST */

#endif  // CDBBASE_ADAPTER_ITR_HH

---