---

CdbBdb2RooNTupleConverter.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdb2RooNTupleConverter.cc,v 1.1 2005/04/23 06:29:43 gapon Exp $

/// The implementation of the CdbBdb2RooNTupleConverter class.
/**
  * @see CdbBdb2RooNTupleConverter
  */
#include "BaBar/BaBar.hh"

#include "CdbRooConversionFwk/CdbBdb2RooNTupleConverter.hh"

#include "CdbRooTable/CdbRooNTupleBaseR.hh"
#include "CdbRooTable/CdbRooNTupleR.hh"

#include "CdbBase/CdbTransaction.hh"

#include "CdbBdb/CdbBdbSchemaUtils.hh"

#include "CdbBdbShared/CdbBdbShared.hh"

#include "CdbBdbTable/CdbBdbNTupleBaseP.hh"
#include "CdbBdbTable/CdbBdbNTupleP.hh"

#include "ErrLogger/ErrLog.hh"

#include <TClass.h>

#include <string>
#include <vector>
#include <iostream>
using std::endl;

template< class P,
          class R,
          class P_ELEMENT_CONVERSION_RULES,
          class R_ELEMENT_CONVERSION_RULES >
CdbBdb2RooNTupleConverter< P,
                           R,
                           P_ELEMENT_CONVERSION_RULES,
                           R_ELEMENT_CONVERSION_RULES >::CdbBdb2RooNTupleConverter( ) :
    CdbBdb2RooPayloadConverter<P,R>( )
{
    const char* fatalStr = "CdbBdb2RooNTupleConverter::CdbBdb2RooNTupleConverter( ) -- FATAL";

  // Get and verify the 'P' type name

    std::string pTypeName = "";
    {
      // To get types we need a transaction.

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

      // ATTENTION: If 'P' is not a valid persistent type known to the current
      //            Objectivity/DB schema then the compilations will abort below.

        ooTypeNumber pTypeNumber = ooTypeN( P );

        if( !CdbBdbSchemaUtils::instance( ).typeNumberToClassName( pTypeNumber,
                                                                   pTypeName ))
            ErrMsg(fatal) << fatalStr << endl
                          << "    Failed to translate the Objectivity/DB type number " << pTypeNumber << " of the" << endl
                          << "    passed as a template parameter of the class into the corresponding type name." << endmsg;

        if( !CdbBdbSchemaUtils::instance( ).isA( pTypeNumber,
                                                 ooTypeN( CdbBdbNTupleP< typename P::ElementType > )))
            ErrMsg(fatal) << fatalStr << endl
                          << "    The passed as a parameter of the template Objectivity/DB type number " << pTypeNumber << endl
                          << "    doesn't correspond to a persistent class deriving from the abtract model" << endl
                          << "    specified by the  CdbBdbNTupleP<T> class with type number " << ooTypeN( CdbBdbNTupleP< typename P::ElementType > ) << endmsg;
    }

  // Get and verify the "Roo" type name.
  //
  // ATTENTION: If 'R' is not a valid persistent type known to the current
  //            ROOT/CINT dictionary then the compilations will abort below.

    const std::string rTypeName = R::Class( )->GetName( );
    {
        if( !R::Class( )->InheritsFrom( CdbRooNTupleR< typename R::ElementType >::Class( )))
            ErrMsg(fatal) << fatalStr << endl
                          << "    The passed as a parameter of the template CINT/ROOT persistent type doesn't" << endl
                          << "    derive from \"" << CdbRooNTupleR< typename R::ElementType >::Class( )->ClassName( ) << "\"," << endl
                          << "    which is base class of N-Tuples in the \"Roo\" technology." << endmsg;
    }
}

template< class P,
          class R,
          class P_ELEMENT_CONVERSION_RULES,
          class R_ELEMENT_CONVERSION_RULES >
CdbStatus
CdbBdb2RooNTupleConverter< P,
                           R,
                           P_ELEMENT_CONVERSION_RULES,
                           R_ELEMENT_CONVERSION_RULES >::userDefinedConversion( const BdbRef(BdbObject)& theInputObjectRef,
                                                                                R*&                      theOutputObjectPtr ) const
{
    const char* errorStr = "<anonymous>::CdbBdb2RooNTupleConverter::userDefinedConversion( )";

  // The following (isValid) test will make sure that a caller passes a non-zero
  // object of the proper type. Objectivity/Db will check the type compatibility
  // during this assignment.

    BdbHandle( P ) inputObjectH = (const BdbRef( P )&)theInputObjectRef;
    if( !inputObjectH.isValid( )) {
        ErrMsg(error) << errorStr << endl
                      << "    An invalid oject passed to the procedure." << endmsg;
        return CdbStatus::Error;
    }

  // Get the parameters of the input tuple

    unsigned int nColumns = inputObjectH->columns( );

    std::string name        = inputObjectH->name( );
    std::string description = inputObjectH->description( );

    std::vector<std::string> columnNames;
    inputObjectH->column_names( columnNames );

    unsigned int nRows = inputObjectH->rows( );

  // Create the output tuple of the final type

    R* outputTuplePtr = new R( nColumns,
                               name,
                               description ,
                               columnNames);

  // Do the actual conversion
  //
  // ATTENTION: Watch for the conversin of element types.

    for( unsigned int r = 0; r < nRows; ++r ) {

      // Get the input row.

        std::vector< typename P::ElementType > pRow;

        if( CdbStatus::Success != inputObjectH->get_row( pRow,
                                                         r )) {
            ErrMsg(error) << errorStr << endl
                          << "    Failed to get a row number " << r << " from a persistent tuple" << endl
                          << "    object " << inputObjectH.sprint( ) << endmsg;

            return CdbStatus::Error;
        }
        if( pRow.size( ) != nColumns ) {
            ErrMsg(error) << errorStr << endl
                          << "    The row number " << r << " got from an input persistent tuple object " << inputObjectH.sprint( ) << endl
                          << "    has incorrect length " << pRow.size( ) << " instead of expected " << nColumns << "." << endl
                          << "    The input object may be corrupted or its class may have been incorrectly" << endl
                          << "    implemented." << endmsg;

            return CdbStatus::Error;
        }

      // Translate the above obtained row into the one whose elements
      // have the output type type.
      //
      // NOTE: As an intermediate step of this conversion we'll be doing the inderect (through
      //       an intermediate "mediator" transient type of elements) translation of elements.
      //
      //       Any compilation errors at the conversion statement would mean possible
      //       incompatibility between element type converters, or wrong types passed
      //       as arameters of the current template.

        std::vector< typename R::ElementType > rRow( nColumns );

        for( unsigned int c = 0; c < nColumns; ++c )
            rRow[c] = R_ELEMENT_CONVERSION_RULES::to_persistent( P_ELEMENT_CONVERSION_RULES::to_transient( pRow[c] ));

      // Store the converted row into the output tuple

        if( CdbStatus::Success != outputTuplePtr->append_row( rRow )) {

            ErrMsg(error) << errorStr << endl
                          << "    Failed to append a row number " << r << " to an persistent tuple object." << endmsg;

            delete outputTuplePtr;
            return CdbStatus::Error;
        }
    }

  // RETURNED OBJECT OWNERHIP NOTE:
  //
  //    The ownership is returned to a caller along with the object.

    theOutputObjectPtr = outputTuplePtr;

    return CdbStatus::Success;
}

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

---