---

CdbNTupleAlgorithms.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbNTupleAlgorithms.cc,v 1.5 2004/08/06 05:54:41 bartoldu Exp $

/// The implementation of the CdbNTupleAlgorithms class.
/**
  * @see CdbNTupleAlgorithms
  */

#include "BaBar/BaBar.hh"

#include "CdbTable/CdbNTupleAlgorithms.hh"
#include "CdbTable/CdbNTupleFactory.hh"
#include "CdbTable/CdbNTupleIsLessComparator.hh"

#include <iostream>
using std::cout;
using std::endl;

/*
 * The obsolete interface and implementation of the algorithm
 *
template < class T, unsigned int NCOL >
CdbStatus
CdbNTupleMerge(       CdbCPtr<CdbNTuple<T,NCOL> >& theOutputPtr,
                const CdbCPtr<CdbNTuple<T,NCOL> >& thePrototypePtr,
                const CdbCPtr<CdbNTuple<T,NCOL> >& theExtraPtr )
{
    const char* errorStr = "CdbNTupleMerge<T,NCOL>(output,prototype,extra) - ERROR";

    if( thePrototypePtr.isNull( )) return CdbStatus::IllegalParameters;
    if( theExtraPtr.isNull( ))     return CdbStatus::IllegalParameters;

  // Create a clone of the "prototype" tuple and initialize the resulting
  // pointer with this clone. Upon the successfull completion of the algorithm
  // the output pointer will be repointed onto this new tuple.
  //
  // NOTE; This operation will automatically copy all metadata and rows
  //       from the "prototype" into the resulting tuple.

    CdbCPtr<CdbNTuple<T,NCOL> > resultPtr = thePrototypePtr->clone( );

  // Copy over rows from the "extra" tuple and append them by the end
  // of the "output" one.

    unsigned int nRows = theExtraPtr->rows( );
    for( unsigned int i = 0; i < nRows; ++i ) {

        std::vector<T> row;
        if( CdbStatus::Success != theExtraPtr->get_row( row, i )) {
            cout << errorStr << endl
                 << "    Failed to read the row number " << i << " from the \"extra\" tuple." << endl;
            return CdbStatus::Error;
        }
        if( CdbStatus::Success != resultPtr->append_row( row )) {
            cout << errorStr << endl
                 << "    Failed to append the row number " << i << " read from the \"extra\" tuple" << endl
                 << "    by the end of the resulting tuple." << endl;
            return CdbStatus::Error;
        }
    }

  // Repoint the "output" tuple to point onto the newely created
  // resulting tuple.

    theOutputPtr = resultPtr;

    return CdbStatus::Success;
}
*
* There is a better implementation below.
*/

template < class NTUPLE >
CdbStatus
CdbNTupleMerge(       CdbCPtr<NTUPLE>& theOutputPtr,
                const CdbCPtr<NTUPLE>& thePrototypePtr,
                const CdbCPtr<NTUPLE>& theExtraPtr )
{
    const char* errorStr = "CdbNTupleMerge<NTUPLE>(output,prototype,extra) - ERROR";

    if( thePrototypePtr.isNull( )) return CdbStatus::IllegalParameters;
    if( theExtraPtr.isNull( ))     return CdbStatus::IllegalParameters;

  // Create a clone of the "prototype" tuple and initialize the resulting
  // pointer with this clone. Upon the successfull completion of the algorithm
  // the output pointer will be repointed onto this new tuple.
  //
  // NOTE; This operation will automatically copy all metadata and rows
  //       from the "prototype" into the resulting tuple.

    CdbCPtr<NTUPLE> resultPtr = thePrototypePtr->clone( );

  // Copy over rows from the "extra" tuple and append them by the end
  // of the "output" one.

    unsigned int nRows = theExtraPtr->rows( );
    for( unsigned int i = 0; i < nRows; ++i ) {

        std::vector<typename NTUPLE::element_type> row;
        if( CdbStatus::Success != theExtraPtr->get_row( row, i )) {
            cout << errorStr << endl
                 << "    Failed to read the row number " << i << " from the \"extra\" tuple." << endl;
            return CdbStatus::Error;
        }
        if( CdbStatus::Success != resultPtr->append_row( row )) {
            cout << errorStr << endl
                 << "    Failed to append the row number " << i << " read from the \"extra\" tuple" << endl
                 << "    by the end of the resulting tuple." << endl;
            return CdbStatus::Error;
        }
    }

  // Repoint the "output" tuple to point onto the newely created
  // resulting tuple.

    theOutputPtr = resultPtr;

    return CdbStatus::Success;
}

/*
 * The obsolete interface and implementation of the algorithm
 *
template < class T, unsigned int NCOL >
CdbStatus
CdbNTupleAppend(       CdbCPtr<CdbNTuple<T,NCOL> >& theOutputPtr,
                 const CdbCPtr<CdbNTuple<T,NCOL> >& theInputPtr )
{
    const char* errorStr = "CdbNTupleAppend<T,NCOL>(output,input) - ERROR";

    if( theOutputPtr.isNull( )) return CdbStatus::IllegalParameters;
    if( theInputPtr.isNull( ))  return CdbStatus::IllegalParameters;

  // Copy over rows from the "input" tuple and append them by the end
  // of the "output" one.

    unsigned int nRows = theInputPtr->rows( );
    for( unsigned int i =0; i < nRows; ++i ) {
        std::vector<T> row;
        if( CdbStatus::Success != theInputPtr->get_row( row, i )) {
            cout << errorStr << endl
                 << "    Failed to read the row number " << i << " from the \"input\" tuple." << endl;
            return CdbStatus::Error;
        }
        if( CdbStatus::Success != theOutputPtr->append_row( row )) {
            cout << errorStr << endl
                 << "    Failed to append the row number " << i << " read from the \"input\" tuple" << endl
                 << "    by the end of the \"output\" tuple." << endl;
            return CdbStatus::Error;
        }
    }

    return CdbStatus::Success;
}
*
* There is a better implementation below.
*/

template < class NTUPLE >
CdbStatus
CdbNTupleAppend(       CdbCPtr<NTUPLE >& theOutputPtr,
                 const CdbCPtr<NTUPLE >& theInputPtr )
{
    const char* errorStr = "CdbNTupleAppend<NTUPLE>(output,input) - ERROR";

    if( theOutputPtr.isNull( )) return CdbStatus::IllegalParameters;
    if( theInputPtr.isNull( ))  return CdbStatus::IllegalParameters;

  // Copy over rows from the "input" tuple and append them by the end
  // of the "output" one.

    unsigned int nRows = theInputPtr->rows( );
    for( unsigned int i =0; i < nRows; ++i ) {
        std::vector<typename NTUPLE::element_type> row;
        if( CdbStatus::Success != theInputPtr->get_row( row, i )) {
            cout << errorStr << endl
                 << "    Failed to read the row number " << i << " from the \"input\" tuple." << endl;
            return CdbStatus::Error;
        }
        if( CdbStatus::Success != theOutputPtr->append_row( row )) {
            cout << errorStr << endl
                 << "    Failed to append the row number " << i << " read from the \"input\" tuple" << endl
                 << "    by the end of the \"output\" tuple." << endl;
            return CdbStatus::Error;
        }
    }

    return CdbStatus::Success;
}

/*
 * The obsolete interface and implementation of the algorithm
 *
template < class T, unsigned int NCOL >
CdbStatus
CdbNTupleCopy(       CdbCPtr<CdbNTuple<T,NCOL> >& theOutputTuple,
               const CdbCPtr<CdbNTuple<T,NCOL> >& theInputTuple )
{
    if( theInputTuple.isNull( )) return CdbStatus::IllegalParameters;

  // Create a clone of the "input" tuple and repoint the "output" pointer
  // onto the clone.
  //
  // NOTE; This operation will automatically copy all metadata and rows
  //       from the "input" into the "output" tuple.

    theOutputTuple = theInputTuple->clone( );

    return CdbStatus::Success;
}
*
* There is a better implementation below.
*/

template < class NTUPLE >
CdbStatus
CdbNTupleCopy(       CdbCPtr<NTUPLE>& theOutputTuple,
               const CdbCPtr<NTUPLE>& theInputTuple )
{
    if( theInputTuple.isNull( )) return CdbStatus::IllegalParameters;

  // Create a clone of the "input" tuple and repoint the "output" pointer
  // onto the clone.
  //
  // NOTE; This operation will automatically copy all metadata and rows
  //       from the "input" into the "output" tuple.

    theOutputTuple = theInputTuple->clone( );

    return CdbStatus::Success;
}

/*
 * The obsolete interface and implementation of the algorithm
 *
template < class T,
           unsigned int NCOL_OUT,
           unsigned int NCOL_LEFT,
           unsigned int NCOL_RIGHT >
CdbStatus
CdbNTupleGlue_utility<T,NCOL_OUT,NCOL_LEFT,NCOL_RIGHT>::glue(       CdbCPtr<CdbNTuple<T,NCOL_OUT> >&   theOutputPtr,
                                                              const CdbCPtr<CdbNTuple<T,NCOL_LEFT> >&  theLeftPtr,
                                                              const CdbCPtr<CdbNTuple<T,NCOL_RIGHT> >& theRightPtr,
                                                              const bool                               allowRenamingOfColumnsFlag )
{
    const char* errorStr = "CdbNTupleGlue_utility<T,NCOL_OUT,NCOL_LEFT,NCOL_RIGHT>::glue(output,left,right) - ERROR";
    const char* fatalStr = "CdbNTupleGlue_utility<T,NCOL_OUT,NCOL_LEFT,NCOL_RIGHT>::glue(output,left,right) - FATAL ERROR";

    if( NCOL_OUT != NCOL_LEFT + NCOL_RIGHT ) return CdbStatus::ConflictOfParameters;

    if( theLeftPtr.isNull( ))  return CdbStatus::IllegalParameters;
    if( theRightPtr.isNull( )) return CdbStatus::IllegalParameters;

  // Check for the column names (in-)compatibility.

    std::vector<std::string> outputColumnNames;
    {
        std::vector<std::string> leftColumnNames;
        theLeftPtr->column_names( leftColumnNames );

        std::vector<std::string> rightColumnNames;
        theRightPtr->column_names( rightColumnNames );

        outputColumnNames = leftColumnNames;

        for( unsigned int right = 0; right < NCOL_RIGHT; ++right ) {

            std::string rightName = rightColumnNames[right];

            if( CdbNTupleBase::is_system_name( rightName )) {

              // That's a defaul t"system" name. Then we need to force its replacement
              // with the right default name regardeless of the mode the algorithm
              // is used. This is because "system" names of columns from the right tuple
              // would be unsuitable when these columns will "shifted" right.

                rightName = CdbNTupleBase::default_column_name( NCOL_LEFT + right );

            } else {

              // For regular names we should check for the duplicates.

                for( unsigned int left = 0; left < NCOL_LEFT; ++left ) {

                    if( rightName == leftColumnNames[left] ) {

                      // Replace column names at a right column with the corresponding default
                      // value for that position if a conflict with the naming of left columns
                      // is found, and if the algorithm is allowed so.

                        if( allowRenamingOfColumnsFlag ) {
                            rightName = CdbNTupleBase::default_column_name( NCOL_LEFT + right );
                            break;
                        } else {
                            return CdbStatus::ConflictOfParameters;
                        }
                    }
                }
            }
            outputColumnNames.push_back( rightName );
        }
    }

  // Create a resulting tuple, which will be returned back to a caller
  // upon the successfull completion of the algorithm.
  //
  // NOTE: We've commited not to modify the value of the "output" pointer
  //       in case of any problems.

    CdbCPtr< CdbNTuple< T, NCOL_OUT > > resultPtr =
        CdbNTupleFactory< T, NCOL_OUT >::createSimple( outputColumnNames,
                                                       theLeftPtr->name( ),
                                                       theLeftPtr->description( ));
    if( resultPtr.isNull( )) {

        cout << fatalStr << endl
             << "    Failed to create an output tuple using the \"simple\" factory method." << endl
             << "    It can be either a memory management problem of the current application" << endl
             << "    or improperly implemented hierarchy of N-Tupe classes." << endl;

        assert( 0 );

        return CdbStatus::Error;
    }

  // Copy over rows from the both input tuples and merge them into the output
  // one. Fill elements with default values (using default constructor of the
  // current element type) for shortest tuple.

    unsigned int nLeftRows   = theLeftPtr->rows( );
    unsigned int nRightRows  = theRightPtr->rows( );
    unsigned int nOutputRows = ( nLeftRows > nRightRows ? nLeftRows : nRightRows );

    for( unsigned int i = 0; i < nOutputRows; ++ i ) {

        std::vector<T> leftRow;
        {

            if( i < nLeftRows ) {

              // Get and check the width of a row from the left tuple

                if( CdbStatus::Success != theLeftPtr->get_row( leftRow, i )) {
                    cout << errorStr << endl
                         << "    Failed to read the row number " << i << " from the \"left\" tuple." << endl;
                    return CdbStatus::Error;
                }
                if( NCOL_LEFT != leftRow.size( )) {

                    cout << fatalStr << endl
                         << "    The number of elements " << leftRow.size( ) << " in a vector returned" << endl
                         << "    from the \"left\" tuple when reading the row number " << i << " does not match" << endl
                         << "    the width of the tuple. The tuple is supposed to be " << NCOL_LEFT << " in width." << endl
                         << "    This can be a problem with the actual implementation of the tuple class." << endl;

                    assert( 0 );

                    return CdbStatus::Error;
                }

            } else {

              // Fill that row with default values by resizing the vector
              //
              // NOTE: See the specifications for the std::vector class for details.

                leftRow.resize( NCOL_LEFT );
            }
        }
        
      // Get and check the width of a row from the right tuple

        std::vector<T> rightRow;
        {
            if( i < nRightRows ) {

              // Get and check the width of a row from the right tuple

                if( CdbStatus::Success != theRightPtr->get_row( rightRow, i )) {
                    cout << errorStr << endl
                         << "    Failed to read the row number " << i << " from the \"right\" tuple." << endl;
                    return CdbStatus::Error;
                }
                if( NCOL_RIGHT != rightRow.size( )) {

                    cout << fatalStr << endl
                         << "    The number of elements " << rightRow.size( ) << " in a vector returned" << endl
                         << "    from the \"right\" tuple when reading the row number " << i << " does not match" << endl
                         << "    the width of the tuple. The tuple is supposed to be " << NCOL_RIGHT << " in width." << endl
                         << "    This can be a problem with the actual implementation of the tuple class." << endl;

                    assert( 0 );

                    return CdbStatus::Error;
                }

            } else {

              // Fill that row with default values by resizing the vector.
              //
              // NOTE: See the specifications for the std::vector class for details.

                rightRow.resize( NCOL_RIGHT );
            }
        }

      // Write the merged row into the resulting tuple

        std::vector<T> resultRow = leftRow;

        resultRow.insert( resultRow.end( ),
                          rightRow.begin( ),
                          rightRow.end( ));

        if( CdbStatus::Success != resultPtr->append_row( resultRow )) {
            cout << errorStr << endl
                 << "    Failed to append the row number " << i << " merged from both input tuples" << endl
                 << "    by the end of the \"output\" tuple." << endl;
            return CdbStatus::Error;
        }
    }

  // Substitute the original "output" pointer with the above created resulting one.

    theOutputPtr = resultPtr;

    return CdbStatus::Success;
}
*
* There is a better implementation below.
*/

template < class NTUPLE_OUT,
           class NTUPLE_LEFT,
           class NTUPLE_RIGHT >
CdbStatus
CdbNTupleGlue(       CdbCPtr<NTUPLE_OUT>&   theOutputPtr,
               const CdbCPtr<NTUPLE_LEFT>&  theLeftPtr,
               const CdbCPtr<NTUPLE_RIGHT>& theRightPtr,
               const bool                   allowRenamingOfColumnsFlag )
{
    const char* errorStr = "CdbNTupleGlue<NTUPLE_OUT,NTUPLE_LEFT,NTUPLE_RIGHT>(output,left,right) - ERROR";
    const char* fatalStr = "CdbNTupleGlue<NTUPLE_OUT,NTUPLE_LEFT,NTUPLE_RIGHT>(output,left,right) - FATAL ERROR";

    if( NTUPLE_OUT::ncol != NTUPLE_LEFT::ncol + NTUPLE_RIGHT::ncol ) return CdbStatus::ConflictOfParameters;

    if( theLeftPtr.isNull( ))  return CdbStatus::IllegalParameters;
    if( theRightPtr.isNull( )) return CdbStatus::IllegalParameters;

  // Check for the column names (in-)compatibility.

    std::vector<std::string> outputColumnNames;
    {
        std::vector<std::string> leftColumnNames;
        theLeftPtr->column_names( leftColumnNames );

        std::vector<std::string> rightColumnNames;
        theRightPtr->column_names( rightColumnNames );

        outputColumnNames = leftColumnNames;

        for( unsigned int right = 0; right < NTUPLE_RIGHT::ncol; ++right ) {

            std::string rightName = rightColumnNames[right];

            if( CdbNTupleBase::is_system_name( rightName )) {

              // That's a defaul t"system" name. Then we need to force its replacement
              // with the right default name regardeless of the mode the algorithm
              // is used. This is because "system" names of columns from the right tuple
              // would be unsuitable when these columns will "shifted" right.

                rightName = CdbNTupleBase::default_column_name( NTUPLE_LEFT::ncol + right );

            } else {

              // For regular names we should check for the duplicates.

                for( unsigned int left = 0; left < NTUPLE_LEFT::ncol; ++left ) {

                    if( rightName == leftColumnNames[left] ) {

                      // Replace column names at a right column with the corresponding default
                      // value for that position if a conflict with the naming of left columns
                      // is found, and if the algorithm is allowed so.

                        if( allowRenamingOfColumnsFlag ) {
                            rightName = CdbNTupleBase::default_column_name( NTUPLE_LEFT::ncol + right );
                            break;
                        } else {
                            return CdbStatus::ConflictOfParameters;
                        }
                    }
                }
            }
            outputColumnNames.push_back( rightName );
        }
    }

  // Create a resulting tuple, which will be returned back to a caller
  // upon the successfull completion of the algorithm.
  //
  // NOTE: We've commited not to modify the value of the "output" pointer
  //       in case of any problems.

    CdbCPtr< NTUPLE_OUT > resultPtr =
        CdbNTupleFactory< typename NTUPLE_OUT::element_type, NTUPLE_OUT::ncol >::createSimple( outputColumnNames,
                                                                                               theLeftPtr->name( ),
                                                                                               theLeftPtr->description( ));
    if( resultPtr.isNull( )) {

        cout << fatalStr << endl
             << "    Failed to create an output tuple using the \"simple\" factory method." << endl
             << "    It can be either a memory management problem of the current application" << endl
             << "    or improperly implemented hierarchy of N-Tupe classes." << endl;

        assert( 0 );

        return CdbStatus::Error;
    }

  // Copy over rows from the both input tuples and merge them into the output
  // one. Fill elements with default values (using default constructor of the
  // current element type) for shortest tuple.

    unsigned int nLeftRows   = theLeftPtr->rows( );
    unsigned int nRightRows  = theRightPtr->rows( );
    unsigned int nOutputRows = ( nLeftRows > nRightRows ? nLeftRows : nRightRows );

    for( unsigned int i = 0; i < nOutputRows; ++ i ) {

        std::vector<typename NTUPLE_LEFT::element_type> leftRow;
        {

            if( i < nLeftRows ) {

              // Get and check the width of a row from the left tuple

                if( CdbStatus::Success != theLeftPtr->get_row( leftRow, i )) {
                    cout << errorStr << endl
                         << "    Failed to read the row number " << i << " from the \"left\" tuple." << endl;
                    return CdbStatus::Error;
                }
                if( NTUPLE_LEFT::ncol != leftRow.size( )) {

                    cout << fatalStr << endl
                         << "    The number of elements " << leftRow.size( ) << " in a vector returned" << endl
                         << "    from the \"left\" tuple when reading the row number " << i << " does not match" << endl
                         << "    the width of the tuple. The tuple is supposed to be " << NTUPLE_LEFT::ncol << " in width." << endl
                         << "    This can be a problem with the actual implementation of the tuple class." << endl;

                    assert( 0 );

                    return CdbStatus::Error;
                }

            } else {

              // Fill that row with default values by resizing the vector
              //
              // NOTE: See the specifications for the std::vector class for details.

                leftRow.resize( NTUPLE_LEFT::ncol );
            }
        }
        
      // Get and check the width of a row from the right tuple

        std::vector<typename NTUPLE_RIGHT::element_type> rightRow;
        {
            if( i < nRightRows ) {

              // Get and check the width of a row from the right tuple

                if( CdbStatus::Success != theRightPtr->get_row( rightRow, i )) {
                    cout << errorStr << endl
                         << "    Failed to read the row number " << i << " from the \"right\" tuple." << endl;
                    return CdbStatus::Error;
                }
                if( NTUPLE_RIGHT::ncol != rightRow.size( )) {

                    cout << fatalStr << endl
                         << "    The number of elements " << rightRow.size( ) << " in a vector returned" << endl
                         << "    from the \"right\" tuple when reading the row number " << i << " does not match" << endl
                         << "    the width of the tuple. The tuple is supposed to be " << NTUPLE_RIGHT::ncol << " in width." << endl
                         << "    This can be a problem with the actual implementation of the tuple class." << endl;

                    assert( 0 );

                    return CdbStatus::Error;
                }

            } else {

              // Fill that row with default values by resizing the vector.
              //
              // NOTE: See the specifications for the std::vector class for details.

                rightRow.resize( NTUPLE_RIGHT::ncol );
            }
        }

      // Write the merged row into the resulting tuple

        std::vector<typename NTUPLE_OUT::element_type> resultRow = leftRow;

        resultRow.insert( resultRow.end( ),
                          rightRow.begin( ),
                          rightRow.end( ));

        if( CdbStatus::Success != resultPtr->append_row( resultRow )) {
            cout << errorStr << endl
                 << "    Failed to append the row number " << i << " merged from both input tuples" << endl
                 << "    by the end of the \"output\" tuple." << endl;
            return CdbStatus::Error;
        }
    }

  // Substitute the original "output" pointer with the above created resulting one.

    theOutputPtr = resultPtr;

    return CdbStatus::Success;
}

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

---