---

CdbBdbNTupleP2T.hh

Go to the documentation of this file.

#ifndef CDBBDBTABLE_NTUPLE_P2T_HH
#define CDBBDBTABLE_NTUPLE_P2T_HH

// File and Version Information:
//      $Id: CdbBdbNTupleP2T.hh,v 1.3 2004/08/06 05:54:31 bartoldu Exp $

#include "CdbBase/CdbObject.hh"

#include "CdbBdb/CdbBdbObjectConvertor.hh"

#include "CdbBdbTable/CdbBdbNTupleConversionImpl.hh"
#include "CdbBdbTable/CdbBdbNTupleConversionRules.hh"

/// A front-end class for "persistent-to-transient" conversion facility
/**
  * DESCRIPTION:
  *
  *   This class is meant to be used as a primary API for user's code who needs
  *   to convert a persistent n-tuple into the corresponding transient form.
  *   The convertor's design allows to avoid passing explicit template parameters
  *   of (both transient and persistent) n-tuples.
  *
  *   Note that this is a template class having template method(s). The only parameter
  *   of the template class is:
  *
  *     ELEMENT_CONVERSION_RULES
  *
  *   which is a policy for user defined element conversion. The policy is meant
  *   to help in situations when there is no straight-forward mapping between
  *   transient and persistent types of elements, or in cases when a user wishes
  *   to pack rather small transient types (bit strings, enums, etc.) into
  *   bigger persistent elements.
  *
  *     NOTE: this way of transient-to-persistent and vs. transformation
  *           of elements has its own "pros" and "cons".
  *
  *   By default the conversion facility uses default rules for elements conversion.
  *   See class's specialization below.
  *
  * @see class CdbNTupleConversionImpl
  * @see class CdbBdbNTupleConversionRules_UseDefault
  * @see class CdbBdbNTupleConversionRules_Default
  */
template < class ELEMENT_CONVERSION_RULES = CdbBdbNTupleConversionRules_UseDefault >
class CdbBdbNTupleP2T {

public:

  /// Try to convert (from a persistent reference)
  /**
    * @see CdbBdbNTupleConversionImpl::to_transient()
    */
    template < class        T,
               unsigned int NCOL >
    static CdbStatus convert( CdbCPtr< CdbNTuple< T,NCOL > >& thePtr,
                              const ooRef(BdbObject)&         thePersRef )
    {
        return CdbBdbNTupleConversionImpl< T, NCOL, ELEMENT_CONVERSION_RULES >::to_transient( thePtr,
                                                                                              thePersRef );
    }

  /// Try to convert (from a persistent reference) (regular pointer version)

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

  /// Try to convert (from a generic CdbObject)
  /**
    * Unlike the above defined method this one accepts a smart pointer onto
    * a "generic" metadata object representing a persistent object at the level of
    * the transient CDB API.
    *
    * @see CdbBdbNTupleConversionImpl::to_transient()
    * @see class CdbBdbObjectConvertor
    */
    template < class        T,
               unsigned int NCOL >
    static CdbStatus convert( CdbCPtr< CdbNTuple< T,NCOL > >& thePtr,
                              const CdbObjectPtr&             theObjectPtr )
    {
        BdbHandle(BdbObject) objectH;
        CdbStatus status = CdbBdbObjectConvertor::narrow( objectH,
                                                          theObjectPtr );
        if( CdbStatus::Success != status ) return status;

        return convert( thePtr,
                        objectH );
    }

  /// Try to convert (from a generic CdbObject) (regular pointer version)

    template < class        T,
               unsigned int NCOL >
    static CdbStatus convert( CdbNTuple< T,NCOL >*& thePtr,
                              const CdbObjectPtr&   theObjectPtr )
    {
        BdbHandle(BdbObject) objectH;
        CdbStatus status = CdbBdbObjectConvertor::narrow( objectH,
                                                          theObjectPtr );
        if( CdbStatus::Success != status ) return status;

        return convert( thePtr,
                        objectH );
    }
};

/// A specialized version of the above defined conversion class
/**
  * This class is used when default conversion rules for alements of
  * the class seems to be sufficient. Here is an example of how it can
  * be used:
  *
  *   ooRef(BdbObject)                 pObjectRef;        // A persistent object to be created
  *   CdbCPtr< CdbNTuple< float, 3 > > tuplePtr = ...;    // Have a pointer pointing onto an existing tuple
  *   BdbRefAny                        hintRef = ...;     // Obtain a placement and clustering hint
  *
  *   if( CdbStatus::Success != CdbBdbNTupleP2T<>::convert( pObjectRef, tuplePtr, hintRef )) {
  *       std::cout << "error: failed to convert a transient n-tuple into a persistent." << std::endl;
  *       ...
  *   }
  *
  */
template < >
class CdbBdbNTupleP2T< CdbBdbNTupleConversionRules_UseDefault > {

public:


  /// Try to convert (from a persistent reference)
 
    template < class        T,
               unsigned int NCOL >
    static CdbStatus convert( CdbCPtr< CdbNTuple< T,NCOL > >& thePtr,
                              const ooRef(BdbObject)&         thePersRef )
    {
      // Delegate the actual work to the above defined non-specialized version
      // of the conversion facility.

        return CdbBdbNTupleP2T< CdbBdbNTupleConversionRules_Default<T> >::convert( thePtr,
                                                                                   thePersRef );
    }

  /// Try to convert (from a persistent reference) (regular pointer version)
 
    template < class        T,
               unsigned int NCOL >
    static CdbStatus convert( CdbNTuple< T,NCOL >*&   thePtr,
                              const ooRef(BdbObject)& thePersRef )
    {
        return CdbBdbNTupleP2T< CdbBdbNTupleConversionRules_Default<T> >::convert( thePtr,
                                                                                   thePersRef );
    }

  /// Try to convert (from a generic CdbObject)

    template < class        T,
               unsigned int NCOL >
    static CdbStatus convert( CdbCPtr< CdbNTuple< T,NCOL > >& thePtr,
                              const CdbObjectPtr&             theObjectPtr )
    {
      // Delegate the actual work to the above defined non-specialized version
      // of the conversion facility.

        return CdbBdbNTupleP2T< CdbBdbNTupleConversionRules_Default<T> >::convert( thePtr,
                                                                                   theObjectPtr );
    }

  /// Try to convert (from a generic CdbObject) (regular pointer version)

    template < class        T,
               unsigned int NCOL >
    static CdbStatus convert( CdbNTuple< T,NCOL >*& thePtr,
                              const CdbObjectPtr&   theObjectPtr )
    {
        return CdbBdbNTupleP2T< CdbBdbNTupleConversionRules_Default<T> >::convert( thePtr,
                                                                                   theObjectPtr );
    }
};

#endif // CDBBDBTABLE_NTUPLE_P2T_HH

---