---

CdbBdb2RooPayloadConversionTool.cc

Go to the documentation of this file.

// A tool for populating ROOT I/O based database installations with user defined
// "payload' objects taken from "Bdb" based installations (teh "Shared" technology).

#include "BaBar/BaBar.hh"

#include "BdbCond/BdbObject.hh"

#include "CdbBase/CdbTransaction.hh"

#include "CdbBdbShared/CdbBdbShared.hh"

#include "CdbBdbTable/CdbBdbNTupleSimpleImplP_PrimitiveTypes.hh"

#include "CdbRooReadonly/CdbRooReadonly.hh"

#include "CdbRooTable/CdbRooNTupleSimpleImplR.hh"

#include "CdbRooTests/CdbRooTestClassR.hh"

#include "CdbRooConversionFwk/CdbRooConverterBase.hh"
#include "CdbRooConversionFwk/CdbBdb2RooNTupleConverter.hh"
#include "CdbRooConversionFwk/CdbBdb2RooPayloadConversionFwk.hh"
#include "CdbRooConversionFwk/CdbBdb2RooPayloadMrgConverter.hh"

#include <stdio.h>  // sscanf()

#include <string>
#include <vector>

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

#include <sstream>
using std::ostringstream;

namespace {

  // Parameters of the command. They're passed via command line.
  
    bool       verboseModeFlag = false;
    bool         debugModeFlag = false;
    bool doNotCompressModeFlag = false;

  /// Loader for ROOT I/O dictionary of persistent classes
  /**
    * Default constructors of the 'payload' classes to be loaded from CDB
    * needs to be executed at least one to bring in the corresponding dictionary.
    * Otherwise the loaded objects will have incomplete shape (they'll be TObject-s only).
    */
    void loadPayloadClassesDictionary( )
    {
        CdbRooNTupleSimpleImplR< UInt_t   > test3;
        CdbRooNTupleSimpleImplR< Double_t > test4;
    }

  // Helpers meant to translate command line parameters

    bool translate_UShort_t( UShort_t&   theValue,
                             const char* theString )
    {
        assert( 0 != theString );

        unsigned value;
        if( 1 != sscanf( theString, "%u", &value )) return false;
        if( value > 0xFFFF ) return false;

        theValue = (UShort_t)value;

        return true;
    }

    bool translate_bool( bool&       theValue,
                         const char* theString )
    {
        assert( 0 != theString );

        unsigned value;
        if( 1 != sscanf( theString, "%u", &value )) return false;

        theValue = ( value != 0 );

        return true;
     }

  // Report the right syntax of the commandline parameters

    void usage( const std::string& theMessage = "" )
    {
        if( theMessage != "" ) cerr << theMessage << endl;
        cerr << "Usage: testing       <origin_id> <condition_id> <0|1> <partition_id> <cluster_id> <increment_id>" << endl
             << "       testing_merge <origin_id> <condition_id> <0|1> <partition_id> <cluster_id> <increment_id>" << endl
             << "       conversion    <definition_file>" << endl
             << "       [-verbose] [-debug] [-do_not_compress]" << endl;
    }

  /// Simple converter to test merging multiple conditions

    class SimpleMergingConverter : public CdbBdb2RooPayloadMrgConverter< CdbBdbNTupleSimpleImplP< ooFloat64 >,
                                                                         CdbRooTestClassR > {
    public:

      /// Implement a user-defined conversion (merged version)

        virtual CdbStatus userDefinedConversion( const BdbRef(BdbObject)&                theMainInputObjectRef,
                                                 const std::vector< BdbRef(BdbObject) >& theExtraObjectsList,
                                                 CdbRooTestClassR*&                      theOutputObjectPtr ) const
        {
            ostringstream description;
            description << "Object constructed from: " << theMainInputObjectRef.sprint( );
            for( unsigned int i = 0; i < theExtraObjectsList.size( ); ++i ) {
                description << ", " << theExtraObjectsList[i].sprint( );
            }
            theOutputObjectPtr = new CdbRooTestClassR( description.str( ));
            return CdbStatus::Success;
        }
    };
}

////////////////////////////////////
// Start execution of the program //
////////////////////////////////////

int
main( int argc, char* argv[] )
{
loadPayloadClassesDictionary();

  // Translate input parameters

    enum CommandType { CMD_TESTING = 0,
                       CMD_TESTING_MERGE,
                       CMD_CONVERSION
    };
    CommandType command = CMD_TESTING;

    int numArgs = argc - 1;
    int nextArg = 1;

    UShort_t originId            = 0;
    UShort_t conditionId         = 0;
    bool     isPartitionableFlag = false;
    UShort_t partitionId         = 0;
    UShort_t clusterId           = 0;
    UShort_t incrementId         = 0;

    const char* definitionFile = 0;

    if( 0 == numArgs ) {
        usage( );
        return 1;
    }
    if( numArgs > 0 ) {

        const std::string commandName = argv[nextArg];
        nextArg++;
        numArgs--;

        if( commandName == "testing" ) {

            command = CMD_TESTING;

            if( numArgs >= 6 ) {

                if( !translate_UShort_t( originId,
                                         argv[nextArg++] )) {
                    usage( "failed to translate the <origin_id> parameter of the command" );
                    return 1;
                }
                numArgs--;

                if( !translate_UShort_t( conditionId,
                                         argv[nextArg++] )) {
                    usage( "failed to translate the <condition_id> parameter of the command" );
                    return 1;
                }
                numArgs--;

                if( !translate_bool( isPartitionableFlag,
                                     argv[nextArg++] )) {
                    usage( "failed to translate the condition type flag (allowed values: 0|1) parameter of the command" );
                    return 1;
                }
                numArgs--;

                if( !translate_UShort_t( partitionId,
                                         argv[nextArg++] )) {
                    usage( "failed to translate the <partition_id> parameter of the command" );
                    return 1;
                }
                numArgs--;

                if( !translate_UShort_t( clusterId,
                                         argv[nextArg++] )) {
                    usage( "failed to translate the <cluster_id> parameter of the command" );
                    return 1;
                }
                numArgs--;

                if( !translate_UShort_t( incrementId,
                                         argv[nextArg++] )) {
                    usage( "failed to translate the <increment_id> parameter of the command" );
                    return 1;
                }
                numArgs--;

            } else {
                usage( "illegal number of parameters for the command" );
                return 1;
            }

        } else if( commandName == "testing_merge" ) {

            command = CMD_TESTING_MERGE;

            if( numArgs >= 6 ) {

                if( !translate_UShort_t( originId,
                                         argv[nextArg++] )) {
                    usage( "failed to translate the <origin_id> parameter of the command" );
                    return 1;
                }
                numArgs--;

                if( !translate_UShort_t( conditionId,
                                         argv[nextArg++] )) {
                    usage( "failed to translate the <condition_id> parameter of the command" );
                    return 1;
                }
                numArgs--;

                if( !translate_bool( isPartitionableFlag,
                                     argv[nextArg++] )) {
                    usage( "failed to translate the condition type flag (allowed values: 0|1) parameter of the command" );
                    return 1;
                }
                numArgs--;

                if( !translate_UShort_t( partitionId,
                                         argv[nextArg++] )) {
                    usage( "failed to translate the <partition_id> parameter of the command" );
                    return 1;
                }
                numArgs--;

                if( !translate_UShort_t( clusterId,
                                         argv[nextArg++] )) {
                    usage( "failed to translate the <cluster_id> parameter of the command" );
                    return 1;
                }
                numArgs--;

                if( !translate_UShort_t( incrementId,
                                         argv[nextArg++] )) {
                    usage( "failed to translate the <increment_id> parameter of the command" );
                    return 1;
                }
                numArgs--;

            } else {
                usage( "illegal number of parameters for the command" );
                return 1;
            }

        } else if( commandName == "conversion" ) {

            command = CMD_CONVERSION;

            if( numArgs >= 1 ) {
                definitionFile = argv[nextArg];
                nextArg++;
                numArgs--;
            } else {
                usage( "illegal number of parameters for the command" );
                return 1;
            }

        } else {
            usage( "unknown command" );
            return 1;
        }
    }

  // Translate optional arguments

    while( numArgs > 0 ) {
        if( std::string( "-verbose" ) == argv[nextArg] ) {

            verboseModeFlag = true;

            numArgs --;
            nextArg ++;

        } if( std::string( "-debug" ) == argv[nextArg] ) {

            debugModeFlag = true;

            numArgs --;
            nextArg ++;

        } if( std::string( "-do_not_compress" ) == argv[nextArg] ) {

            doNotCompressModeFlag = true;

            numArgs --;
            nextArg ++;

        } else {
            cerr << "unknown command option or parameter: \"" << argv[nextArg] << "\"." << endl;
            usage( );
            return 1;
        }
    }
    if( numArgs > 0 ) {
        usage( "extra parameter which couldn't be recognized by the parser passsed to the procedure" );
        return 1;
    }

  // Initialize the context of the Objectivity/DB based CDB

    CdbBdbShared::forceLoad( );

    CdbTransaction bdbReadOnlyTransactionStartsHere( CdbBdbShared::technology( ),
                                                     CdbBdbShared::implementation( ));

  // Initialize the context of the ROOT I/O based CDB

    CdbRooReadonly::forceLoad( );

    CdbTransaction rooReadOnlyTransactionStartsHere( CdbRooReadonly::technology( ),
                                                     CdbRooReadonly::implementation( ));

  // Tell the conversion framework about our preferences regarding
  // the "verbose" & "debug" flags.

    CdbBdb2RooPayloadConversionFwk::setVerbose      (         verboseModeFlag );
    CdbBdb2RooPayloadConversionFwk::setDebug        (           debugModeFlag );
    CdbBdb2RooPayloadConversionFwk::setDoNotCompress(   doNotCompressModeFlag );

  // Instantiate converters in the dictionary. They'll be used by the actual
  // conversion sequence to be engaged below.

    CdbStatus result = CdbStatus::Error;
    {
        CdbCPtr< CdbRooConverterBase > converterPtr( new CdbBdb2RooNTupleConverter< CdbBdbNTupleSimpleImplP< ooFloat64 >,
                                                                                               CdbRooNTupleSimpleImplR< Double_t > >( ));

        if( CdbStatus::Success != ( result = CdbBdb2RooPayloadConversionFwk::registerConverter( converterPtr ))) {
            cerr << "failed to register the converter for persistent tuples because of: " << result << endl;
            return 1;
        }
        if( verboseModeFlag )
            cout << "added converter for \"" << converterPtr->inputClassName( ) << "\" -> \"" << converterPtr->outputClassName( ) << "\"." << endl;
    }
    {
        CdbCPtr< CdbRooConverterBase > converterPtr( new SimpleMergingConverter( ));

        if( CdbStatus::Success != ( result = CdbBdb2RooPayloadConversionFwk::registerConverter( converterPtr ))) {
            cerr << "failed to register the converter for persistent tuples because of: " << result << endl;
            return 1;
        }
        if( verboseModeFlag )
            cout << "added converter for \"" << converterPtr->inputClassName( ) << "\" -> \"" << converterPtr->outputClassName( ) << "\"." << endl;
    }

  // Execite the specified command

    switch( command ) {

    case CMD_TESTING:

        result = CdbBdb2RooPayloadConversionFwk::testConversion( originId,
                                                                 conditionId,
                                                                 isPartitionableFlag,
                                                                 partitionId,
                                                                 clusterId,
                                                                 incrementId );
        return ( CdbStatus::Success == result ? 0 : 1 );

    case CMD_TESTING_MERGE:

        {
            cout << "How many other conditions you want to merge in addition to the main one?";

            unsigned int nExtra;
            cin >> nExtra;

            if( nExtra < 1 ) {
                cerr << "Wrong number of conditions. Aborting the test." << endl;
                return 1;
            }
            cout << "Enter the ID-s of these conditions separated by spaces:";

            std::vector<UShort_t> conditionIds( 1, conditionId );

            for( unsigned int i = 0; i < nExtra; ++i ) {
                UShort_t id;
                cin >> id;
                conditionIds.push_back( id );
            }

            result = CdbBdb2RooPayloadConversionFwk::testConversion( originId,
                                                                     conditionIds,
                                                                     isPartitionableFlag,
                                                                     partitionId,
                                                                     clusterId,
                                                                     incrementId );
            return ( CdbStatus::Success == result ? 0 : 1 );
        }

    case CMD_CONVERSION:

        result = CdbBdb2RooPayloadConversionFwk::doConversion( definitionFile );
        return ( CdbStatus::Success == result ? 0 : 1 );
    }
    return 1;
}

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

---