---

CdbObjectTranslator.hh

Go to the documentation of this file.

#ifndef CDB_OBJECT_TRANSLATOR_HH
#define CDB_OBJECT_TRANSLATOR_HH

// File and Version Information:
//      $Id: CdbObjectTranslator.hh,v 1.1 2005/05/03 20:59:51 gapon Exp $

#include "CdbBase/CdbType2Id.hh"
#include "CdbBase/CdbObjectPtrFwd.hh"

#include <string>

/// The very base class for persistent-to-transient translators of payload objects
/**
  * This class is an element of the "persistent-to-transient" translation facility
  * extending the core CDB API and allowing a better (and more confined) controll
  * over persistency in client applications.
  *
  * Roles of this class are:
  *
  *   1. to represent translators in a dictionary of ones
  *   2. to handle the type-independednt context of translators
  *   3. to force its subclasses to implement an actual translation procedure
  *   4. to provide a type-safe wrapper to the translation procedure
  */
class CdbObjectTranslator {

private:

  /// Default constructor (NOT IMPLEMENTED)

    CdbObjectTranslator( );

  /// Copy constructor (NOT IMPLEMENTED)

    CdbObjectTranslator( const CdbObjectTranslator& );

  /// Assignment operator (NOT IMPLEMENTED)

    CdbObjectTranslator& operator=( const CdbObjectTranslator& );

protected:

  /// Normal constructor

    CdbObjectTranslator( unsigned int       theTransientTypeId,
                         const std::string& thePersistentTypeName ) :
        _transientTypeId   (theTransientTypeId),
        _persistentTypeName(thePersistentTypeName)
    { }

  /// Translate into a transient object
  /**
    * This method is supposed to be implemented by subclasses. In case of its successful
    * completion (CdbStatus::Success) it's supposed to set up the supplied reference to
    * point onto a new transinet object. The ownership of this object is also returned with
    * the object.
    *
    * DESIGN NOTE:
    *
    *   It's up to the caller of this method to interprete the actual type of
    *   the returned object. That type is the one corresponding to a value of
    *   the "transient type identifier" passed to the class's constructor.
    *   Normally, this method shouldn't be used by users directly. It has to be
    *   wrrapped into a type-safe ionterface.
    *
    * @see CdbObjectTranslator::transient()
    *
    * If the operation, for some, reason should fail then the corresponding error status
    * (other than CdbStatus::Success) has to be returned.
    */
    virtual CdbStatus toTransient( void*&              theTransientPtr, /**< the pointer to be initialized with the result */
                                   const CdbObjectPtr& theObjectPtr     /**< the input metadata object */
                                 ) const = 0;
public:

  /// Destructor

    virtual ~CdbObjectTranslator( ) { }

  /// Returns a transient type number

    unsigned int transientTypeId( ) const { return _transientTypeId; }

  /// Returns a transient type number

    std::string persistentTypeName( ) const { return _persistentTypeName; }

  /// Translate into a transient object (type-safe wrapper)
  /**
    * The only role of this wrapper is to make sure that 
    */
    template< class T >
    CdbStatus transient( T*&                 theTransientPtr, /**< the pointer to be initialized with the result */
                         const CdbObjectPtr& theObjectPtr     /**< the input metadata object */
                       ) const
    {
        if( transientTypeId( ) != CdbType2Id<T>::id( )) return CdbStatus::IllegalParameters;
        if( theObjectPtr.isNull( )) return CdbStatus::IllegalParameters;
        return toTransient( (void*&)theTransientPtr,
                            theObjectPtr );
    }

private:

    unsigned int _transientTypeId;
    std::string  _persistentTypeName;
};

#endif  // CDB_OBJECT_TRANSLATOR_HH

---