---

CdbRooConverterBase.hh

Go to the documentation of this file.

#ifndef CDBROOCONVERSIONFWK_BDB_2_ROO_PAYLOAD_CONVERTER_BASE_HH
#define CDBROOCONVERSIONFWK_BDB_2_ROO_PAYLOAD_CONVERTER_BASE_HH

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

#include "CdbBase/CdbCPtr.hh"

#include "CdbRoo/CdbRooObjectR.hh"

#include "BdbCond/BdbObject.hh"

#include <string>
#include <vector>

class TTree;
class TBranch;

/// The abstract base class for user defined convertor classes
/**
  * More details...
  */
class CdbRooConverterBase {

private:

  /// The default constructor (NOT IMPLEMENTED)
  /**
    * It just doesn't make a sense in the current context not to know names
    * of persistent classes.
    */
    CdbRooConverterBase( );

protected:

  /// The normal constructor.
  /**
    * Is used to cache the names of input and output classes.
    *
    * DESIGN NOTE:
    *
    *   Note, that for the sake of consistency of this class's design the constructor
    *   (as well as other forms of constructing or loading the current context) is only
    *   available to subclasses.
    */
    CdbRooConverterBase( const std::string& theInputClassName,
                                    const std::string& theOutputClassName
                                  );

  /// The copy constructor

    CdbRooConverterBase( const CdbRooConverterBase& theOther );

  /// The assignment operator

    CdbRooConverterBase& operator=( const CdbRooConverterBase& theOther );

public:

  /// The destructor.

    virtual ~CdbRooConverterBase( );

  /// The input class name

    const std::string& inputClassName( ) const { return _inputClassName; }

  /// The input class name

    const std::string& outputClassName( ) const { return _outputClassName; }

  /// A wrapper method for the conversion operation
  /**
    * This is the method to be called to initiate the actual conversion. The method
    * will evaluate the final type of the input object to make sure that it matches
    * the one specified in the constructor before calling a user implemented
    * conversion sequence. It will also make sure that a type of an output object
    * produced by the user defined conversion sequence matches the one specified
    * in the constructor.
    *
    * A valid non-zero persistent reference is expected as an input object.
    *
    * The method also has a list of "extra" objects to be used in addition to
    * the input object to produce the output one. The list can be empty. Also see notes
    * on the converter's type as it's defined by the CdbRooConverterBase::mergingConverter()
    * method defined below.
    *
    * The method would return CdbStatus::Success in case of its successfull completion,
    * or CdbStatus::IllegalParameters in case of the type mismatch (on either step),
    * or a error status returned by te user defined sequence.
    *
    * The method is supposed to be implemented by a subclass where an actual persistent
    * type is known at a compilation time.
    *
    * @see CdbRooConverterBase::CdbRooConverterBase()
    * @see CdbRooConverterBase::mergingConverter()
    */
    virtual CdbStatus conversion( const BdbRef(BdbObject)&                theInputObjectRef,
                                  const std::vector< BdbRef(BdbObject) >& theExtraObjectsList
                                ) = 0;

  /// A type of the converter
  /**
    * The true value returned by the method means that a list of extra objects
    * passed down to the CdbRooConverterBase::conversion() method shouldn't
    * be empty. Otherwise the CdbStatus::IllegalParameters method is returned
    * by the conversion method.
    *
    * If the returned value is false then it's all opposite - the list must be empty.
    * Otherwise the CdbStatus::Error method is returned by the conversion method.
    *
    * The default value type of the converter doesn't allow merging multiple input
    * objects. This behavior can be overriden by subclasses.
    *
    * @see CdbRooConverterBase::conversion()
    */
    virtual bool mergingConverter( ) const { return false; };

  /// Create a new branch with specified parameters
  /**
    * This operation is put here to let the conversion framework an access to a mechanics
    * of the TTree/TBranch. This mechanics had to be moved into this hierarchy
    * because of a change in the public interface of the TTree class in between
    * the following versions of ROOT:
    *
    *   4.02/00
    *   4.03/02
    *
    * As of the version "4.03/02" of ROOT's TTree the branch constructor expects an exact
    * type of objects to be stored in the branch.
    *
    * The method is supposed to be implemented by a subclass where an actual persistent
    * type is known at a compilation time.
    */
    virtual TBranch* branchConstructor( TTree&      theTree,
                                        const char* theBranchName ) = 0;

private:

    std::string _inputClassName;
    std::string _outputClassName;
};

#endif  // CDBROOCONVERSIONFWK_BDB_2_ROO_PAYLOAD_CONVERTER_BASE_HH

---