---

CdbNTupleTestApp.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbNTupleTestApp.cc,v 1.7 2004/08/06 05:54:41 bartoldu Exp $
#include "BaBar/BaBar.hh"

/// This is a test application for the collection of n-tuple classes
/**
  * This application would test instantiation, destruction and use of
  * the transient n-tuple-s.
  *
  * The tests do not do any operations involving any kind of persistentcy.
  */

#include "CdbTable/CdbNTupleFactory.hh"
#include "CdbTable/CdbNTupleAlgorithms.hh"
#include "CdbTable/CdbNTuplePrint.hh"
#include "CdbTable/CdbNTupleIsLessComparatorDefaultImpl.hh"

#include "BdbTime/BdbTime.hh"

#include <iostream>
#include <fstream>

#include <stdio.h>
#include <assert.h>

#include <string>
#include <vector>
using std::cout;
using std::endl;
using std::fstream;
using std::ofstream;

//////////////////////////
// Forward declarations //
//////////////////////////

namespace {

  // Test gor n-tuple-s of the float type of various width

    void test_tuple_of_float( );

  // Test for n-tuples of the std::string type 

    void test_tuple_of_string( );
};

//////////
// main //
//////////

int main( int    argc,
          char** argv )
{
    ::test_tuple_of_float( );
    ::test_tuple_of_string( );

    return 0;
}

/////////////////////
// Implementations //
/////////////////////

namespace {

  /// fill_unique facility
  /**
    * A utility function to fill an n-tuple with unique values
    * of its element's type using the specified generator supplied for
    * the elements type.
    */

    template < class T >
    struct Generator {
        static T value( const unsigned int theRow,
                        const unsigned int theColumn );
    };

    template < >
    struct Generator<float> {
        static float value( const unsigned int theRow,
                            const unsigned int theColumn )
        {
            float result = 0.0 + theRow;
            if( theColumn < 10 ) {
                result += 0.1 * theColumn;
            } else {
                result += value( 0, theColumn / 10 ) + 0.1 * value( 0, theColumn % 10 );
            }
            return result;
        }
    };

    template < >
    struct Generator<std::string> {
        static std::string value( const unsigned int theRow,
                                  const unsigned int theColumn )
        {
            char buf[12];
            sprintf( buf, "r:%u c:%u", theRow, theColumn );
            return std::string( buf );
        }
    };

    template < class T, unsigned int NCOL >
    void
    fill_unique( CdbCPtr< CdbNTuple< T,NCOL > >& thePtr,
                 const unsigned int              theNumberOfRows )
    {
        const unsigned int nColumns = thePtr->columns( );

        for( unsigned int row = 0; row < theNumberOfRows; ++row ) {

            std::vector<T> elements;

            for( unsigned int col = 0; col < nColumns; ++col ) {
//                elements.push_back( ::Generator<T>::value( row, col ));
                elements.push_back( ::Generator<T>::value( row % ( 1 + col ), col / 3 ));
            }
            CdbStatus status = thePtr->append_row( elements );
            assert( CdbStatus::Success == status );
        }
    }

  /////////////////////////////////////////////
  // Custom comparator for sorting algorithm //
  /////////////////////////////////////////////

    template < class T, unsigned int NCOL >
    class IsLessComparator : public CdbNTupleIsLessComparator<T,NCOL> {
    public:
        virtual bool isLess( const std::vector<T>& theLeftRow,
                             const std::vector<T>& theRightRow ) const
        {
            assert( NCOL == theLeftRow.size( ));
            assert( NCOL == theRightRow.size( ));

//          cout << "theLeftRow[1] = " << theLeftRow[1] << endl;

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

                if( theLeftRow[i] < theRightRow[i] ) {
                    return true;
                } else if( theRightRow[i] < theLeftRow[i] ) {
                    return false;
                } else {

                  // They're equal - keep checking

                    ;
                }
            }

          // If they're equal then it's up to the sorting algorithm
          // how to treat this result.
          //
          // IMPLEMENTATION NOTE: Returning "true" would cause a crash in
          //                      the current implementation of std::sort()
          //                      algorithm on Linux gcc 2.95.x.

            return false;
        }
    };

  /////////////////////////
  // test_tuple_of_float //
  /////////////////////////

    void test_tuple_of_float( )
    {

      // Local types

        typedef CdbNTuple< float, 10 > MyTuple;
        typedef CdbCPtr< MyTuple > MyTuplePtr;
        typedef CdbNTupleFactory< MyTuple::element_type, MyTuple::ncol > MyTupleFactory;
//        typedef IsLessComparator< MyTuple::element_type, MyTuple::ncol > MyIsLessComparator;
        typedef CdbNTupleIsLessComparatorDefaultImpl< MyTuple::element_type, MyTuple::ncol > MyIsLessComparator;

      // Create and fill tuples

        MyTuplePtr t1Ptr =
            MyTupleFactory::createSimple( );

        MyTuplePtr t2Ptr =
            MyTupleFactory::createSimple( "Table #2",
                                          "Default names for columns.");

        std::vector<std::string> columnNames;
        columnNames.push_back( "First" );
        columnNames.push_back( "Second" );
        columnNames.push_back( "Third" );

        MyTuplePtr t3Ptr =
            MyTupleFactory::createSimple( columnNames,
                                          "Table #3",
                                          "Just a test table with custom column names." );

        ::fill_unique( t3Ptr, 3000 );

      // Dump tuples

        cout << endl;

        CdbNTuplePrint<>::print1( t1Ptr );

        cout << endl;

        CdbNTuplePrint<>::print1( t2Ptr );

        cout << endl;

        CdbNTuplePrint<>::print2( t3Ptr );

        cout << endl;

      // Sort rows in a table using custom algorithm

        cout << "Begin sorting t3Ptr : " << BdbTime::now( ) << endl;

        MyIsLessComparator isLessComparator;
        if( CdbStatus::Success != t3Ptr->sort( &isLessComparator )) {
            cout << "test_tuple_of_float() - failed to sort rows a tuple t3Ptr" << endl;
            return;
        }

        cout << "End   sorting t3Ptr : " << BdbTime::now( ) << endl;

      // Print results

        CdbNTuplePrint<>::print2( t3Ptr );

        cout << endl;

      // Also try printing into a file

        ofstream myFile( "/tmp/CdbNTupleTestApp.output" );

        CdbNTuplePrint<>::print2( myFile, t3Ptr );
    }

  /////////////////////////
  // test_tuple_of_float //
  /////////////////////////

    void test_tuple_of_string( )
    {
      // Local types

        typedef CdbNTuple< std::string, 4 > MyTuple;
        typedef CdbCPtr< MyTuple > MyTuplePtr;
        typedef CdbNTupleFactory< MyTuple::element_type, MyTuple::ncol > MyTupleFactory;

        struct Fill {
            static void row( MyTuplePtr& ptr,
                             const char* s1,
                             const char* s2,
                             const char* s3,
                             const char* s4 )
            {
                std::vector<std::string> row;
                {
                    row.push_back( std::string( s1 ));
                    row.push_back( std::string( s2 ));
                    row.push_back( std::string( s3 ));
                    row.push_back( std::string( s4 ));        
                }
                ptr->append_row( row );
            }
        };

      // Create and fill tuples

        std::vector<std::string> columnNames;
        columnNames.push_back( "First" );
        columnNames.push_back( "Middle" );
        columnNames.push_back( "Last" );
        columnNames.push_back( "Address" );

        MyTuplePtr t1Ptr =
            MyTupleFactory::createSimple( columnNames,
                                          "t1Ptr",
                                          "This table contains the information about my friends" );

        Fill::row( t1Ptr, "Billy", "M",     "Jill",     "123 Deadend, Nowhereland, CA" );
        Fill::row( t1Ptr, "Peter", "B",     "Krouzen",  "5676 Sky Ave, Boston, MA" );
        Fill::row( t1Ptr, "Pierre","Marie", "Delaneuf", "1246 Rue De La Prulay 72, Meyrin, GE, Switzerland" );
        Fill::row( t1Ptr, "Igor",  "A",     "Gaponenko","012345678901234567890123" );

        MyTuplePtr t2Ptr =
            MyTupleFactory::createSimple( "t2Ptr" );

        ::fill_unique( t2Ptr, 5 );

      // Test algorithms

        MyTuplePtr t1CopyPtr;
        if( CdbStatus::Success != CdbNTupleCopy( t1CopyPtr, t1Ptr )) {
            cout << "test_tuple_of_string() - failed to copy a tuple t1Ptr into t1CopyPtr" << endl;
            return;
        }

        MyTuplePtr t3Ptr;
        if( CdbStatus::Success != CdbNTupleMerge( t3Ptr, t1Ptr, t2Ptr )) {
            cout << "test_tuple_of_string() - failed to merge t1Ptr and t2Ptr injto t3Ptr" << endl;
            return;
        }

        MyTuplePtr t4Ptr;
        if( CdbStatus::Success != CdbNTupleCopy( t4Ptr, t1Ptr )) {
            cout << "test_tuple_of_string() - failed to copy a tuple t1Ptr into t4Ptr" << endl;
            return;
        }
        if( CdbStatus::Success != CdbNTupleAppend( t4Ptr, t4Ptr )) {
            cout << "test_tuple_of_string() - failed to append t4Ptr by t4Ptr" << endl;
            return;
        }

      // Create a tuple of double width to test "columns-glue" algorithm

        CdbCPtr< CdbNTuple< MyTuple::element_type, 2 * MyTuple::ncol > > t5Ptr;
        if( CdbStatus::Success != CdbNTupleGlue( t5Ptr, t1Ptr, t2Ptr )) {
            cout << "test_tuple_of_string() - failed to columns-glue t1Ptr and t2Ptr into t5Ptr" << endl;
            return;
        }
        {
          // Test the robustness of an implementation of this algorithm. It should not
          // have any problems to detect (at run time) and reject templates of incompatible width.

            CdbCPtr< CdbNTuple< MyTuple::element_type, 2 * MyTuple::ncol + 1 > > t6Ptr;

            CdbStatus s = CdbNTupleGlue( t6Ptr, t1Ptr, t2Ptr );
            if( CdbStatus::Success != s ) {
                cout << "test_tuple_of_string() - failed to columns-glue t1Ptr and t2Ptr into t6Ptr" << endl
                     << "                         A value of CdbStatus returned is: " << s << endl
                     << "                         Note, that this is an expected result to test the robustness" << endl
                     << "                         of the algorithm." << endl
                     << endl;
            }
        }

      // Dump tuples

        cout << endl;

        CdbNTuplePrint<>::print( t1Ptr,
                                 24,
                                 "  ",
                                 CdbNTuplePrintTypes::ClosedFrame,
                                 CdbNTuplePrintTypes::DoubleHashes );

        cout << endl;

        CdbNTuplePrint<>::print( t1Ptr,
                                 24,
                                 "  ",
                                 CdbNTuplePrintTypes::OpenFrame,
                                 CdbNTuplePrintTypes::SingleXes );

        cout << endl;

        CdbNTuplePrint<>::print1( t2Ptr );

        cout << endl
             << "Copy of t1Ptr:" << endl
             << endl;

        CdbNTuplePrint<>::print1( t1CopyPtr, 24 );

        cout << endl
             << "Row-merge of t1Ptr and t2Ptr:" << endl
             << endl;

        CdbNTuplePrint<>::print2( t3Ptr, 24 );

        cout << endl
             << "Append of t4Ptr and t4Ptr (originally copied from t1Pr):" << endl
             << endl;

        CdbNTuplePrint<>::print1( t4Ptr, 24 );

        cout << endl
             << "Column-merge of t1Ptr and t2Ptr:" << endl
             << endl;

        CdbNTuplePrint<>::print2( t5Ptr, 10 );

      // Use an explicitly specified convertor, although the default one

        cout << endl
             << "Print using an explicitly specified convertor:" << endl
             << endl;

        CdbNTuplePrint< CdbNTuplePrintDefaultConverter< MyTuple::element_type > >::print2( t5Ptr, 10 );

        cout << endl;
    }
};

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

---