---

CdbNTupleSimpleImpl.hh

Go to the documentation of this file.

#ifndef CDB_NTUPLE_SIMPLE_IMPL_HH
#define CDB_NTUPLE_SIMPLE_IMPL_HH

// File and Version Information:
//      $Id: CdbNTupleSimpleImpl.hh,v 1.6 2005/07/26 00:13:41 gapon Exp $

#include "CdbBase/CdbItr.hh"

#include "CdbTable/CdbNTuple.hh"

#include <vector>

/// The simple implementation for an abstract n-tuple class.
/**
  * This implementation stores n-tuple as an STL vector of rows.
  *
  * @see class CdbNTuple
  */
template < class T,
           unsigned int NCOL >
class CdbNTupleSimpleImpl : public CdbNTuple<T,NCOL> {

friend class CdbNTupleFactory<T,NCOL>;  // to create objects of this class

protected:

  /// The default constructor
  /**
    * @see CdbNTuple::CdbNTuple()
    */
    CdbNTupleSimpleImpl( );

  /// The constructor
  /**
    * @see CdbNTuple::CdbNTuple()
    */
    CdbNTupleSimpleImpl( const std::string& theName,
                         const std::string& theDescription );

  /// The constructor
  /**
    * @see CdbNTuple::CdbNTuple()
    */
    CdbNTupleSimpleImpl( const std::vector<std::string>& theCollumnNames,
                         const std::string&              theName,
                         const std::string&              theDescription );

  /// The copy constructor
  /**
    * Copy the local context.
    */
    CdbNTupleSimpleImpl( const CdbNTupleSimpleImpl<T,NCOL>& theOther );

  /// The assignment operator
  /**
    * Copy the local context.
    */
    CdbNTupleSimpleImpl<T,NCOL>& operator=( const CdbNTupleSimpleImpl<T,NCOL>& theOther );

  /// The destructor
  /**
    */
    virtual ~CdbNTupleSimpleImpl( );

public:

  /// Make a ("deep") clone of a tuple
  /**
    * @see CdbNTuple::rows()
    */
    virtual CdbNTuple<T,NCOL>* clone( ) const;

  /// Get the current size (the number of rows) of n-tuple
  /**
    * @see CdbNTuple::rows()
    */
    virtual unsigned int rows( ) const;

  /// Resize the current size (the number of rows) of n-tuple
  /**
    * @see CdbNTuple::set_rows()
    */
    virtual CdbStatus set_rows( unsigned int theNewSize );

  /// Resize the current size (the number of rows) of n-tuple using a prototype
  /**
    * @see CdbNTuple::set_rows()
    */
    virtual CdbStatus set_rows( unsigned int theNewSize,
                                const T&     thePrototype );

  /// Append a new row
  /**
    * @see CdbNTuple::append_row()
    */
    virtual CdbStatus append_row( const std::vector<T>& theRow );

  /// Insert a whole row of elements after the specified one
  /**
    * @see CdbNTuple::insert_row()
    */
    virtual CdbStatus insert_row( const std::vector<T>& theRow,
                                  unsigned int          theRowNumber );

  /// Replace a whole row of elements at specified position
  /**
    * @see CdbNTuple::replace_row()
    */
    virtual CdbStatus replace_row( const std::vector<T>& theRow,
                                   unsigned int          theRowNumber );

  /// Get a whole row of elements
  /**
    * @see CdbNTuple::get_row()
    */
    virtual CdbStatus get_row( std::vector<T>& theRow,
                               unsigned int    theRowNumber ) const;

  /// Get a whole column by its number
  /**
    * @see CdbNTuple::get_column()
    */
    virtual CdbStatus get_column( std::vector<T>& theColumn,
                                  unsigned int    theColumnNumber ) const;

  /// Get a whole column by its name
  /**
    * @see CdbNTuple::get_column()
    */
    virtual CdbStatus get_column( std::vector<T>&    theColumn,
                                  const std::string& theColumnName ) const;

  /// Read an element (specify column by its number)
  /**
    * @see CdbNTuple::get_element()
    */
    virtual CdbStatus get_element( T&           theValue,
                                   unsigned int theRowNumber,
                                   unsigned int theColumnNumber ) const;

  /// Read an element (specify column by its name)
  /**
    * @see CdbNTuple::get_element()
    */
    virtual CdbStatus get_element( T&                 theValue,
                                   unsigned int       theRowNumber,
                                   const std::string& theColumnName ) const;

  /// Update a single an element (specify column by its number)
  /**
    * @see CdbNTuple::set_element()
    */
    virtual CdbStatus set_element( const T&     theValue,
                                   unsigned int theRowNumber,
                                   unsigned int theColumnNumber );

  /// Update a single an element (specify column by its name)
  /**
    * @see CdbNTuple::set_element()
    */
    virtual CdbStatus set_element( const T&           theValue,
                                   unsigned int       theRowNumber,
                                   const std::string& theColumnName );

  /// Find all rows whose elements at specified (by its number) column have this value
  /**
    * @see CdbNTuple::find_row()
    */
    virtual CdbStatus find_row( CdbItr<unsigned int>& theIterator,
                                unsigned int          theColumnNumber,
                                const T&              theValue ) const;

  /// Find all rows whose elements at specified  (by its name) column have this value
  /**
    * @see CdbNTuple::find_row()
    */
    virtual CdbStatus find_row( CdbItr<unsigned int>& theIterator,
                                const std::string&    theColumnName,
                                const T&              theValue ) const;

  /// Sort rows using specified comparator
  /**
    * @see CdbNTuple::sort()
    */
    virtual CdbStatus sort( const CdbNTupleIsLessComparator<T,NCOL>* theComparatorPtr );

public:

  /// The internal reprsentation of a raw in the n-tuple.
  /**
    * NOTE: This class is made public since it's used ouside the current template
    *       in the internal implementation of the "sort" method.
    */
    struct Row {

      // Constructors

        Row( )
        { };

        Row( const T& thePrototypeElement )
        {
            for( unsigned int i = 0; i < NCOL; ++i ) element[i] = thePrototypeElement;
        }

        Row( const std::vector<T>& theRow )
        {
            const unsigned int num = theRow.size( );
            const unsigned int num2copy = ( num < NCOL ? num : NCOL );

            for( unsigned int i = 0; i < num2copy; ++i ) element[i] = theRow[i];
        }

        Row( const std::vector<T>& theRow,
             const T&              thePrototypeElement )
        {
            const unsigned int num = theRow.size( );
            const unsigned int num2copy = ( num < NCOL ? num : NCOL );

            for( unsigned int i = 0;        i < num2copy; ++i ) element[i] = theRow[i];
            for( unsigned int i = num2copy; i < NCOL;     ++i ) element[i] = thePrototypeElement;
        }

        Row( const Row& theOther )
        {
            for( unsigned int i = 0; i < NCOL; ++i ) element[i] = theOther.element[i];
        }

      // Destructor

        ~Row( )
        { };

      // Operators

        Row& operator=( const Row& theOther )
        {
            if( &theOther != this )
                for( unsigned int i = 0; i < NCOL; ++i ) element[i] = theOther.element[i];

            return *this;
        }

      // Methods

        void toVector( std::vector<T>& theRow ) const
        {
            theRow.clear( );
            for( unsigned int i = 0; i < NCOL; ++i ) theRow.push_back( element[i] );
        }

      // Data storage for elements

        T element[NCOL];
    };

private:

  // The data storage for the n-tuple as a vector of rows

    std::vector< Row > _data;
};

#ifdef     BABAR_COMP_INST
#include "CdbTable/CdbNTupleSimpleImpl.cc"
#endif  // BABAR_COMP_INST

#endif // CDB_NTUPLE_SIMPLE_IMPL_HH

---