---

CdbBdbNTupleConversionImpl.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbNTupleConversionImpl.cc,v 1.4 2004/08/06 05:54:31 bartoldu Exp $

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

#include "BaBar/BaBar.hh"

#include "CdbBdbTable/CdbBdbNTupleConversionImpl.hh"
#include "CdbBdbTable/CdbBdbNTupleSimpleImplP_PrimitiveTypes.hh"
#include "CdbBdbTable/CdbBdbNTupleSimpleImplP_ooVString.hh"

#include "CdbTable/CdbNTupleFactoryFE.hh"

#include "CdbBdb/CdbBdbSchemaUtils.hh"

#include <assert.h>
#include <iostream>
using std::cout;
using std::endl;

////////////////////////////////////////////////////////////////////////////////////////
// CdbBdbNTupleConversionImpl_Helper< PERSISTENT, T, NCOL, ELEMENT_CONVERSION_RULES > //
////////////////////////////////////////////////////////////////////////////////////////

/// Internal implementation helper class
/**
  * This class will perform the actual conversion operations based on the persistent class
  * specified as its template parameter.
  *
  * DESIGN NOTES:
  *
  *   The model of a class passed as a value of the 'PERSISTENT' parameter must be the same one
  *   as in case of the "CdbBdbNTupleP<T>" class except signatures for constructors (the issue
  *   of different constructors will be solved later).
  */
template < class        PERSISTENT,
           class        T,
           unsigned int NCOL,
           class        ELEMENT_CONVERSION_RULES >

struct CdbBdbNTupleConversionImpl_Helper {

  /// Try to convert into a transient form
  /**
    * The method will check if the specified reference matches the specified persistent type
    * as well as parameters of the transient n-tuple.
    */
    static CdbStatus to_transient( CdbNTuple< T, NCOL >*&  thePtr,
                                   const ooRef(BdbObject)& thePersRef )
    {
        const char* errorStr = "CdbBdbNTupleConversionImpl_Helper< PERSISTENT, T, NCOL, ELEMENT_CONVERSION_RULES >::to_transient() - ERROR";

        if( BdbIsNull(thePersRef))  return CdbStatus::IllegalParameters;
        if( !thePersRef.isValid( )) return CdbStatus::IllegalParameters;

      // Verify the actual type and configuration of the persistent tuple
      //
      // NOTE: Perhaps we should use the Active Schema API to avoid problems
      //       with partially loaded v-tables.

        const ooTypeNumber expectedTypeNumber = ooTypeN( PERSISTENT );
        const ooTypeNumber   actualTypeNumber = thePersRef.typeN( );

        if( expectedTypeNumber != actualTypeNumber ) {

            std::string expectedTypeName = "<unknon type name>";

            if( !CdbBdbSchemaUtils::instance( ).typeNumberToClassName( expectedTypeNumber,
                                                                       expectedTypeName )) {
                assert( 0 );
            }
            cout << errorStr << endl
                 << "    A type of persistent object " << thePersRef.sprint( ) << " does not match" << endl
                 << "    the one expected for the transient n-tuple." << endl
                 << "        EXPECTED TYPE: " << actualTypeNumber   << " : \"" << thePersRef.typeName( )    << "\"" << endl
                 << "        ACTUAL TYPE:   " << expectedTypeNumber << " : \"" << expectedTypeName.c_str( ) << "\"." << endl;

            return CdbStatus::Error;
        }

      // Turn it into a reference and then handle (for the performance reason) of
      // the required persistent type.

        ooRef   ( PERSISTENT ) tupleRef = ( ooRef( PERSISTENT )) thePersRef;
        ooHandle( PERSISTENT ) tupleH   = tupleRef;

        assert( tupleH.isValid( ));

        if( NCOL != tupleH->columns( )) {

            cout << errorStr << endl
                 << "    A persistent tuple object " << tupleH.sprint( ) << " passed for the conversion" << endl
                 << "    has incompatible number of columns " << tupleH->columns( ) << "." << endl
                 << "    Meanwhile the following number " << NCOL << " was expected." << endl
                 << "    The further conversion is not possible." << endl;

            return CdbStatus::Error;
        }

      // Create a transient tuple object using the factory and metadata obtained
      // from the persistent object.

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

        CdbNTuple<T,NCOL>* resultPtr = 0;

        CdbNTupleFactoryFE::createSimple( resultPtr,
                                          columnNames,
                                          tupleH->name( ),
                                          tupleH->description( ));
        if( 0 == resultPtr ) {
            cout << errorStr << endl
                 << "    Failed to create a transient n-tuple." << endl;
            return CdbStatus::Error;
        }

      // Copy over rows from the transient tuple into the persistent one

        unsigned int nRows = tupleH->rows( );
        for( unsigned int r = 0; r < nRows; ++r ) {

            std::vector< typename PERSISTENT::ElementType > pRow;
            if( CdbStatus::Success != tupleH->get_row( pRow, r )) {

                cout << errorStr << endl
                     << "    Failed to get a row number " << r << " from a persistent tuple object " << tupleH.sprint( ) << endl;

                return CdbStatus::Error;
            }
            assert( NCOL == pRow.size( ));

            std::vector<T> trRow( NCOL );
            for( unsigned int c = 0; c < NCOL; ++c ) {
                trRow[c] = ELEMENT_CONVERSION_RULES::to_transient( pRow[c] );
            }
            if( CdbStatus::Success != resultPtr->append_row( trRow )) {

                cout << errorStr << endl
                     << "    Failed to append a new row number " << r << " to the transient tuple object." << endl;

                return CdbStatus::Error;
            }
        }

      // Return a smart pointer onto the newely created transient tuple

        thePtr = resultPtr;

        return CdbStatus::Success;
    }

  /// Try to produce a persistent object out of a transient tuple
  /**
    * The method will attempt to use the specified persistent type to store the contents of
    * the specified transient tuple.
    */
    static CdbStatus to_persistent( ooRef(BdbObject)&                      thePersRef,
                                    const CdbCPtr< CdbNTuple< T, NCOL > >& thePtr,
                                    const BdbRefAny&                       theHintRef )
    {
        const char* errorStr = "CdbBdbNTupleConversionImpl_Helper< PERSISTENT, T, NCOL, ELEMENT_CONVERSION_RULES >::to_persistent() - ERROR";

        if( thePtr.isNull( ))      return CdbStatus::IllegalParameters;
        if( BdbIsNull(theHintRef)) return CdbStatus::IllegalParameters;

      // Create a persistent n-tuple objects with specified type and configuration.
      // Copy over the metadata.
      //
      // NOTE: We're using the Persistent type definition from the ELEMENT_CONVERSION_RULES
      //       instead of a type of elements of the transient n-tuple. That's because
      //       users may decide to provide their own type mapping.

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

        ooHandle( PERSISTENT ) tupleH = new( theHintRef ) PERSISTENT( NCOL,
                                                                      thePtr->name( ),
                                                                      thePtr->description( ),
                                                                      columnNames );
        if( !tupleH.isValid( )) {

            cout << errorStr << endl
                 << "    Failed to create a persistent n-tuple object." << endl;

            return CdbStatus::Error;
        }

      // Now, copy over rows from the transient tuple into the persistent one

        unsigned int nRows = thePtr->rows( );
        for( unsigned int r = 0; r < nRows; ++r ) {

            std::vector<T> trRow;
            if( CdbStatus::Success != thePtr->get_row( trRow, r )) {

                cout << errorStr << endl
                     << "    Failed to get a row number " << r << " from a transient tuple." << endl;

                BdbDelete(tupleH);

                return CdbStatus::Error;
            }
            assert( NCOL == trRow.size( ));

            std::vector< typename PERSISTENT::ElementType > pRow( NCOL );
            for( unsigned int c = 0; c < NCOL; ++c ) {
                pRow[c] = ELEMENT_CONVERSION_RULES::to_persistent( trRow[c] );
            }
            if( CdbStatus::Success != tupleH->append_row( pRow )) {

                cout << errorStr << endl
                     << "    Failed to append a new row number " << r << " to the persistent tuple object." << endl;

                BdbDelete(tupleH);

                return CdbStatus::Error;
            }
        }

      // Repack the persistent tuple for the space utilization efficiency

        if( CdbStatus::Success != tupleH->repack( )) {

            cout << errorStr << endl
                 << "    Failed to repack the newely created persistent n-tuple object" << endl
                 << "    for space utilization efficiency." << endl;

            BdbDelete(tupleH);

            return CdbStatus::Error;
        }

      // Return back the reference

        thePersRef = tupleH;

        return CdbStatus::Success;
    }
};

/////////////////////////////////////////////////////////////////////
// CdbBdbNTupleConversionImpl< T, NCOL, ELEMENT_CONVERSION_RULES > //
/////////////////////////////////////////////////////////////////////

// This is an implementation of the generic conversion facility for (currently only) primitive
// types of elements.
//
// It uses the templated "CdbBdbNTupleSimpleImplP" class as the persistent "back-end".

template < class        T,
           unsigned int NCOL,
           class        ELEMENT_CONVERSION_RULES >
CdbStatus
CdbBdbNTupleConversionImpl<T,NCOL,ELEMENT_CONVERSION_RULES>::to_transient( CdbCPtr< CdbNTuple< T,NCOL > >& thePtr,
                                                                           const ooRef(BdbObject)&         thePersRef )
{
    CdbNTuple< T, NCOL >* ptr    = 0;
    CdbStatus             status = to_transient( ptr, thePersRef );

    if( CdbStatus::Success == status ) thePtr = ptr;

    return status;
}

template < class        T,
           unsigned int NCOL,
           class        ELEMENT_CONVERSION_RULES >
CdbStatus
CdbBdbNTupleConversionImpl<T,NCOL,ELEMENT_CONVERSION_RULES>::to_transient( CdbNTuple< T,NCOL >*&   thePtr,
                                                                           const ooRef(BdbObject)& thePersRef )
{
    return CdbBdbNTupleConversionImpl_Helper< CdbBdbNTupleSimpleImplP< typename ELEMENT_CONVERSION_RULES::Persistent >,
                                              T,
                                              NCOL,
                                              ELEMENT_CONVERSION_RULES >::to_transient( thePtr,
                                                                                        thePersRef );
}

template < class        T,
           unsigned int NCOL,
           class        ELEMENT_CONVERSION_RULES >
CdbStatus
CdbBdbNTupleConversionImpl<T,NCOL,ELEMENT_CONVERSION_RULES>::to_persistent( ooRef(BdbObject)&                     thePersRef,
                                                                            const CdbCPtr< CdbNTuple< T,NCOL > >& thePtr,
                                                                            const BdbRefAny&                      theHintRef )
{
    return CdbBdbNTupleConversionImpl_Helper< CdbBdbNTupleSimpleImplP< typename ELEMENT_CONVERSION_RULES::Persistent >,
                                              T,
                                              NCOL,
                                              ELEMENT_CONVERSION_RULES >::to_persistent( thePersRef,
                                                                                         thePtr,
                                                                                         theHintRef );
}

///////////////////////////////////////////////////////////////////////////////
// CdbBdbNTupleConversionImpl< std::string, NCOL, ELEMENT_CONVERSION_RULES > //
///////////////////////////////////////////////////////////////////////////////

// This is an implementation of the specialized conversion facility for the std::string
// types of elements.
//
// It uses the non-=templated "CdbBdbNTupleSimpleImplP_ooVString" class as the persistent "back-end".

template < unsigned int NCOL,
           class        ELEMENT_CONVERSION_RULES >
CdbStatus
CdbBdbNTupleConversionImpl<std::string,NCOL,ELEMENT_CONVERSION_RULES>::to_transient( CdbCPtr< CdbNTuple< std::string, NCOL > >& thePtr,
                                                                                     const ooRef(BdbObject)&                    thePersRef )
{
    CdbNTuple< std::string , NCOL >* ptr    = 0;
    CdbStatus                        status = to_transient( ptr, thePersRef );

    if( CdbStatus::Success == status ) thePtr = ptr;

    return status;
}

template < unsigned int NCOL,
           class        ELEMENT_CONVERSION_RULES >
CdbStatus
CdbBdbNTupleConversionImpl<std::string,NCOL,ELEMENT_CONVERSION_RULES>::to_transient( CdbNTuple< std::string, NCOL >*& thePtr,
                                                                                     const ooRef(BdbObject)&          thePersRef )
{
    return CdbBdbNTupleConversionImpl_Helper< CdbBdbNTupleSimpleImplP_ooVString,
                                              std::string,
                                              NCOL,
                                              ELEMENT_CONVERSION_RULES >::to_transient( thePtr,
                                                                                        thePersRef );
}

template < unsigned int NCOL,
           class        ELEMENT_CONVERSION_RULES >
CdbStatus
CdbBdbNTupleConversionImpl<std::string,NCOL,ELEMENT_CONVERSION_RULES>::to_persistent( ooRef(BdbObject)&                                thePersRef,
                                                                                      const CdbCPtr< CdbNTuple< std::string, NCOL > >& thePtr,
                                                                                      const BdbRefAny&                                 theHintRef )
{
    return CdbBdbNTupleConversionImpl_Helper< CdbBdbNTupleSimpleImplP_ooVString,
                                              std::string,
                                              NCOL,
                                              ELEMENT_CONVERSION_RULES >::to_persistent( thePersRef,
                                                                                         thePtr,
                                                                                         theHintRef );
}

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

---