---

CdbBdbNTupleBaseP.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbNTupleBaseP.cc,v 1.2 2004/03/24 07:17:05 gapon Exp $

/// The implementation file for the CdbBdbNTupleBaseP class
/**
  * @see CdbBdbNTupleBaseP
  */

#include "BaBar/BaBar.hh"

#include "CdbBdbTable/CdbBdbNTupleBaseP.hh"

#include <assert.h>

namespace {

  /// Pack columns from specified vector into internal representation
  /**
    * The packing algorithm is meant to be used to pack an input vector of strings
    * just once to be repacked later on as a whole. The method of packing
    * is not meant to be used for random access to the packaed names.
    */
    void packColumnNames( ooVArray(d_Char)&               theInternalArray,
                          const std::vector<std::string>& theColumnNames )
    {
        d_ULong nColumns = theColumnNames.size( );
        assert( 0 != nColumns );

      // To avoid ineffcient extending of the output array do resize it once
      // to accomodate strings along with the terminator symbols '\0';

        d_ULong nTotalCharacters = 0;
        for( d_ULong column = 0; column < nColumns; ++column )
            nTotalCharacters += 1 + theColumnNames[column].size( );

        theInternalArray.resize( nTotalCharacters );

      // Copy input strings into the output array and add the terminator symbol
      // at the end of each output string.

        d_ULong next = 0;
        for( d_ULong column = 0; column < nColumns; ++column ) {

            d_ULong nCharacters = theColumnNames[column].size( );
            for( d_ULong c = 0; c < nCharacters; ++c ) {
                theInternalArray[next++] = theColumnNames[column][c];
            }
            theInternalArray[next++] = '\0';
        }
        assert( next == nTotalCharacters );     // just a double check
    }

  /// Extract the column names from the internal array into a vector of strings
  /**
    * The size of the output vector will be equal to the number of
    * passed found columns.
    */
    void extractColumnNames( std::vector<std::string>& theColumnNames,
                             const ooVArray(d_Char)&   theInternalArray )
    {
        assert( 0 != theInternalArray.size( ));

      // Reset the output vector

        theColumnNames.resize( 0 );

      // Find null ternminated ('\0') strings in the input array and put them into
      // the output one.


        std::string currentColumn = "";

        d_ULong nTotalCharacters = theInternalArray.size( );
        for( d_ULong c = 0; c < nTotalCharacters; ++c ) {

            d_Char currentChar = theInternalArray[c];
            if( '\0' == currentChar ) {

                theColumnNames.push_back( currentColumn );

                currentColumn = "";

            } else {
                currentColumn += currentChar;
            }
        }
        assert( 0 != theColumnNames.size( ));
    }
};

CdbBdbNTupleBaseP::CdbBdbNTupleBaseP( d_ULong                         theNumberOfColumns,
                                      const std::string&              theName,
                                      const std::string&              theDescription,
                                      const std::vector<std::string>& theColumnNames  ) :
    _columns(theNumberOfColumns),
    _name(theName.c_str( )),
    _description(theDescription.c_str( ))
{
    assert( 0 != _columns );
    assert( _columns == theColumnNames.size( ));

    ::packColumnNames( _columnNames, theColumnNames );
}

CdbBdbNTupleBaseP::~CdbBdbNTupleBaseP( ) 
{ }


d_ULong
CdbBdbNTupleBaseP::columns( ) const
{
    return _columns;
}

std::string
CdbBdbNTupleBaseP::name( ) const
{
    return std::string( _name.head( ));
}

std::string
CdbBdbNTupleBaseP::description( ) const
{
    return std::string( _description.head( ));
}

void
CdbBdbNTupleBaseP::column_names( std::vector<std::string>& theColumnNames ) const
{
    ::extractColumnNames( theColumnNames, _columnNames );
}

/////////////////
// End Of File //
/////////////////

---