---

CdbBdbNTupleSimpleImplP.ddl

Go to the documentation of this file.

#ifndef CDBBDBTABLE_NTUPLE_SIMPLE_IMPL_P_HH
#define CDBBDBTABLE_NTUPLE_SIMPLE_IMPL_P_HH

// File and Version Information:
//      $Id: CdbBdbNTupleSimpleImplP.ddl,v 1.2 2004/03/26 02:45:41 gapon Exp $

#include "CdbBdbShared/CdbBdbSPagedVarrayP.hh"

#include "CdbBdbTable/CdbBdbNTupleP.hh"

/// An implementation of a base class for persistent n-tuples
/**
  * This implementation uses a "paged v-array" for efficient storing of
  * n-tuple elements. The rows are unwrapped into a sigle dimension array
  * in the following order:
  *
  *   - a row with 0 number gets stored first
  *   - an element from a column with the number 0 gets stored first
  *
  * DESIGN NOTES:
  *
  *   This class has been designed for the performance of the insertion operations
  *   versus persistent space utilization efficiency.
  *   That's why the capacity of a "paged" v-array used to store the elements
  *   may be greater than the actual number of elements stored at a given instance
  *   of time.
  *
  *   The current resizing policy for the storage is "x2" meaning that every time
  *   a new row is to be inserted and if there is no free space in the storage
  *   the storage size gets increased by a factor of 2.
  *
  *   Since this policy would result with the %25 average in-efficiency in the use
  *   of the storage then there is a special "repack" method meant to truncate
  *   the storage to match the actual number of rows stored in the array.
  *   Normally the "repack" operation should be called when the construction of
  *   the tuple is finished.
  *
  * @see CdbBdbNTupleBaseP
  * @see CdbBdbNTupleP
  */
template< class E >
class CdbBdbNTupleSimpleImplP : public CdbBdbNTupleP<E> {

private:

  /// Default constructor (IS NOT IMPLEMENTED)

    CdbBdbNTupleSimpleImplP( );

  /// Copy constructor (IS NOT IMPLEMENTED)

    CdbBdbNTupleSimpleImplP( const CdbBdbNTupleSimpleImplP<E>& );

  /// Assignment operator (IS NOT IMPLEMENTED)

    CdbBdbNTupleSimpleImplP<E>& operator=( const CdbBdbNTupleSimpleImplP<E>& );

public:

  /// Constructor
  /**
    * @see CdbBdbNTupleBaseP::CdbBdbNTupleBaseP
    * @see CdbBdbNTupleP::CdbBdbNTupleP
    */
    CdbBdbNTupleSimpleImplP( d_ULong                         theNumberOfColumns,
                             const std::string&              theName,
                             const std::string&              theDescription,
                             const std::vector<std::string>& theColumnNames );

  /// Destructor

    virtual ~CdbBdbNTupleSimpleImplP ( );

  /// Get the number of rows in the tuple
  /**
    * Implements a virtual method defined in the base class.
    *
    * @see CdbBdbNTupleP::rows
    */
    virtual d_ULong rows( ) const;

  /// Get a row at a specified position
  /**
    * Implements a virtual method defined in the base class.
    *
    * @see CdbBdbNTupleP::get_row
    */
    virtual CdbStatus get_row( std::vector<E>& theRow,
                               const d_ULong   theNumber ) const;

  /// Append a row by the end of an existing list
  /**
    * Implements a virtual method defined in the base class.
    *
    * @see CdbBdbNTupleP::append_row
    */
    virtual CdbStatus append_row( const std::vector<E>& theRow );

  /// Repack the internal storage of the tuple
  /**
    * Implements a virtual method defined in the base class.
    *
    * @see CdbBdbNTupleP::repack
    */
    virtual CdbStatus repack( );

private:

  // The actual number of columns. This number may be less than the capacity
  // of the data storage. See 'DESIGN NOTES' at the definition of the current
  // class for details.

    d_ULong _rows;

  // The storage for the tuple elements

    ooRef( CdbBdbSPagedVarrayP<E> ) _dataRef;
};

// Explicit template instantiation for n-tuples of certain types of elements.
//
// In particular this macro is used to make explicit template instantiations
// for so called predefined "primitive types" known to Objy API. N-tuples for
// others (user defined typs of elmenets) should be instantiated using a bit
// more extended form of a macro defined later.
//
// The macro definition assumes that the corresponding template instances have
// already been made for Paged V-Array.
//
// NOTE: This macro can't be used to instantiate n-tuple of "ooBoolean" type
//       because this type may conflicts with "ooInt8" on some platforms.

#define EXPLICIT_INSTANTIATE_CdbBdbNTupleSimpleImplP_NOPVARRAY_1( E ) \
template class CdbBdbNTupleP< E >; \
template class CdbBdbNTupleSimpleImplP< E >

#define EXPLICIT_INSTANTIATE_CdbBdbNTupleSimpleImplP_NOPVARRAY_2( E1, E2 ) \
template class CdbBdbNTupleP< E1, E2 >; \
template class CdbBdbNTupleSimpleImplP< E1, E2 >

/// Macros for the explicit template instantiation of non-trivial types of elements.
/**
  * The macro will provide all the necessary declarations for arbitrary
  * type of elements. This instantiation is required by Objectivity/DDL compilation
  * system to put the new classes into the federation's schema.
  *
  * Note that unlike the primitive types case, this instantiation will also
  * make template instantiation for the Paged V-Array.
  *
  * GENERAL NOTE: Be carefull when doing explicit template instantiations
  *               in Objectivity/DDL API to avoid potential library conflicts
  *               when the same template is defined in two or more packages
  *               (libraries)!!!
  *
  *               As a solution put a common instance of a template into one package
  *               and use it from there.
  */
#define EXPLICIT_INSTANTIATE_CdbBdbNTupleSimpleImplP_1( E ) \
EXPLICIT_INSTANTIATE_CdbBdbSPagedVarrayP_1( E ); \
template class CdbBdbNTupleP< E >; \
template class CdbBdbNTupleSimpleImplP< E >

#define EXPLICIT_INSTANTIATE_CdbBdbNTupleSimpleImplP_2( E1 , E2 ) \
EXPLICIT_INSTANTIATE_CdbBdbSPagedVarrayP_2( E1 , E2 ); \
template class CdbBdbNTupleP< E1 , E2 >; \
template class CdbBdbNTupleSimpleImplP< E1 , E2 >

// Template class implementation

#ifdef    BABAR_COMP_INST
#include "CdbBdbTable/CdbBdbNTupleSimpleImplP.cc"
#endif /* BABAR_COMP_INST */

#endif /* CDBBDBTABLE_NTUPLE_SIMPLE_IMPL_P_HH */

---