---

CdbBdb2RooPayloadConverter.hh

Go to the documentation of this file.

#ifndef CDBROOCONVERSIONFWK_BDB_2_ROO_PAYLOAD_CONVERTER_HH
#define CDBROOCONVERSIONFWK_BDB_2_ROO_PAYLOAD_CONVERTER_HH

// File and Version Information:
//      $Id: CdbBdb2RooPayloadConverter.hh,v 1.2 2005/07/14 16:11:04 jtinslay Exp $

#include "CdbRooConversionFwk/CdbRooConverterBase.hh"

#include <string>

/// The generic "P-R" abstract base class for user defined converters
/**
  * The only role of this interface is to obtain names of persistent types
  * to be converted. This is the class to be normally used by users as a base
  * one when making type-specific converters.
  *
  * IMPLEMENTATION NOTES:
  *
  *   1. The converter will derive the type names of the specified persistent classes
  *   using the current Objectivity/DB (for 'P') schema and ROOT/CINT dictionary (for 'R').
  *
  *   2. The virtual tables for Objectovity/DB classes must be loaded to prevent
  *   crashes in case if the "T* P::transient() const" is defined as the virtual one.
  *
  *   3. The dictionary for the 'R' class must also be available.
  */
template < class P,
           class R >
class CdbBdb2RooPayloadConverter : public CdbRooConverterBase {

private:

  /// Translate the current 'P' type into its name
  /**
    * This is a utility method used by the current class's constructor. The method
    * will cause a run-time abort of the application in case if the desired name
    * can't be obtained.
    *
    * The method will also ensure that the type is a (direct or indirect) subclass of
    * the BdbObject class, which is a very base class of all _primary_ persistent
    * objects stored in Objectivity/DB based CDB implementations.
    *
    * TRANSACTION NOTE:
    *
    *   The method will start (if none exists) a "read-only" mode transaction in
    *   order to obtain the type information for an Objectivity/DB schema.
    *
    * @see BdbObject
    * @see CdbTransaction
    */
    static std::string pTypeName( );

  /// Translate the current 'R' type into its name
  /**
    * This is a utility method used by the current class's constructor. The method
    * will cause a run-time abort of the application in case if the desired name
    * can't be obtained.
    *
    * The type information will be obtained from the ROOT/CINT dictionary which needs
    * to be loaded for the 'R' type. The method will also check if the specified type
    * is a (direct or indirect) subclass of the CdbRooObjectR class, which is a very
    * base class of all _primary_ persistent objects stored in ROOT I/O based CDB
    * implementations.
    *
    * @see CdbRooObjectR
    */
    static std::string rTypeName( );

protected:

  /// The default constructor
  /**
    * Any type incompatibility will cause either compilation errors or run time
    * crash in the constructor.
    *
    * @see CdbBdb2RooPayloadConverter::pTypeName()
    * @see CdbBdb2RooPayloadConverter::rTypeName()
    */
    CdbBdb2RooPayloadConverter( );

  /// The copy constructor

    CdbBdb2RooPayloadConverter( const CdbBdb2RooPayloadConverter<P,R>& theOther );

  /// The assignment operator

    CdbBdb2RooPayloadConverter<P,R>& operator=( const CdbBdb2RooPayloadConverter<P,R>& theOther );

  /// Implement a user-defined conversion
  /**
    * This pure virtual method is supposed to be implemented by subclasses for
    * the specified (in the constructor) pair of classes.
    *
    * The method will be invoked by the below defined "::conversion()" method.
    *
    * The method is supposed to return CdbStatus::Success in case of its successfull
    * completion, or any other value otherwise, which will be treated as a failure.
    * Also when a call is successfull then the ouput object pointer must be filled with
    * a valid pointer onto a nely created object.
    *
    *   NOTE: The output object's ownership is also expected to be returned
    *         with the object.
    *
    * @see CdbBdb2RooPayloadConverter::CdbBdb2RooPayloadConverter()
    * @see CdbBdb2RooPayloadConverter::conversion()
    */
    virtual CdbStatus userDefinedConversion( const BdbRef(BdbObject)& theInputObjectRef,
                                             R*&                      theOutputObjectPtr
                                           ) const = 0;

  /// Get a list of extra objects.
  /**
    * This list is meant to be used by the above defined user defined conversion algorithm
    * when merging multiple input objects into an output one. The list contains "extra"
    * objects in addition to the main input object. The order of objects in the list
    * is defined during the planing phase of the payload conversion. The objects passed
    * in the list ara guaranteed to be valid.
    *
    * The list returned by the method will contain no elements for regular (non-merging)
    * converters.
    *
    * @see CdbRooConverterBase::mergingConverter()
    */
    const std::vector< BdbRef(BdbObject) >& extraObjects( ) const { return _extraObjects; }

public:

  /// The destructor.

    virtual ~CdbBdb2RooPayloadConverter( );

  /// A wrapper method for the conversion operation
  /**
    * Imnplement the corresponding method defined in the base class.
    *
    * @see CdbRooConverterBase::conversion()
    */
    virtual CdbStatus conversion( const BdbRef(BdbObject)&                theInputObjectRef,
                                  const std::vector< BdbRef(BdbObject) >& theExtraObjectsList
                                );

  /// Create a new branch with specified parameters
  /**
    * Imnplement the corresponding method defined in the base class.
    *
    * @see CdbRooConverterBase::branchConstructor()
    */
    virtual TBranch* branchConstructor( TTree&      theTree,
                                        const char* theBranchName );

private:

  /// An optional list of extra objects to be used in the conversion process.
  /**
    * The list will be non-empty if an actual implementation of the converter
    * does allow merging input objects.
    *
    * @see CdbRooConverterBase::mergingConverter()
    */
    std::vector< BdbRef(BdbObject) > _extraObjects;

  /// The object pointer for the resuilting product of the conversion
  /**
    * This pointer is used to create a TBranch object. Then the pointer is filled
    * with converted objects each time the CdbRooConverterBase::conversion()
    * method gets called. It's up to the user of the current class to save result into
    * the corresponding TTree (the one used to create the TBranch object).
    */
    R* _tObjectPtr;
};

#ifdef     BABAR_COMP_INST
#include "CdbRooConversionFwk/CdbBdb2RooPayloadConverter.cc"
#endif  // BABAR_COMP_INST

#endif  // CDBROOCONVERSIONFWK_BDB_2_ROO_PAYLOAD_CONVERTER_HH

---