---

CdbBdbEnvProxy.hh

Go to the documentation of this file.

#ifndef CDBBDB_ENV_PROXY_HH
#define CDBBDB_ENV_PROXY_HH

// File and Version Information:
//      $Id: CdbBdbEnvProxy.hh,v 1.2 2002/09/23 22:39:08 gapon Exp $

#include "CdbBdb/CdbBdbProxyBase.hh"

/// Straightforward implementation for the proxy class
/**
  *     Class CdbBdbEnvProxy
  *
  *     This is a straightforward 1-to-1 proxy implementation assuming
  *     that there is a simple conversion from a persistent class
  *     to a transient one.
  *
  *     The proxy class is parametrized by mean of two template parameters:
  *
  *       T - is a transient class representing a proxy product
  *       P - a persistent class representing a data source
  *
  *     In order to do the "persistent-to-transient" conversion the persistent
  *     class 'P' is expected to expose the following minimal interface:
  *
  *         class P : public ... BdbObject {
  *         public:
  *             T* transient( ) const;
  *         };
  *
  *     Comments:
  *
  *         - the type 'T' must match the first template parameter of the proxy.
  *
  *         - the type 'P' must be either direct or indirect subclass of the 'BdbObject' class
  *
  *         - if there is a hierarchy of persistent classes deriving from the common base
  *           class and if this base class defines the above mentioned "transient" method
  *           as the virtual one then the base class type can be used as the 'P'
  *           instead of any of its subclasses.
  *
  *         - make sure that you have loaded the v-tables for thoses persistent
  *           classes whose objects are loaded through this proxy.
  *
  *     Any incompatibility will be catched during template instantiation
  *     time.
  */
template< class T, class P >
class CdbBdbEnvProxy : public CdbBdbProxyBase<T> {

private:

  /// The default constructor (NOT IMPLEMENTED)

    CdbBdbEnvProxy( );

  /// The copy constructor (NOT IMPLEMENTED)

    CdbBdbEnvProxy( const CdbBdbEnvProxy<T,P>& theProxy );

  /// The asignment operator (NOT IMPLEMENTED)

    CdbBdbEnvProxy<T,P>& operator=( const CdbBdbEnvProxy<T,P>& theProxy );

public:

  /// The normal and default constructor
  /**
    * The only optional argument of the constructor takes the strategy object
    * for locating GenEnv parameters. If 0 pointer is passed then a default
    * strategy will be enforced.
    *
    * Note, that the ownreship of the strategy object is also passed to the constructor.
    */
    CdbBdbEnvProxy( const char*         theDetectorName,
                    const char*         theConditionName,
                    BdbCondDefStrategy* theStrategy = 0 );

  /// The destructor

    virtual ~CdbBdbEnvProxy( );

protected:

  /// The redefined fault handler
  /**
    * Implements the method of a base class.
    *
    * @see CdbBdbProxyBase::redefinedFaultHandler
    */
    virtual T* redefinedFaultHandler( const std::vector<CdbBdbProxyElement>& listOfElements );
};

#ifdef     BABAR_COMP_INST
#include "CdbBdb/CdbBdbEnvProxy.cc"
#endif  // BABAR_COMP_INST

#endif  // CDBBDB_ENV_PROXY_HH

---