---

CdbBdbProxyBase.hh

Go to the documentation of this file.

#ifndef CDBBDB_PROXY_BASE_HH
#define CDBBDB_PROXY_BASE_HH

// File and Version Information:
//      $Id: CdbBdbProxyBase.hh,v 1.12 2005/07/12 21:29:18 jtinslay Exp $

#include "CdbBdb/CdbBdbProxyCache.hh"
#include "ProxyDict/IfdDataProxyTemplate.hh"

class BdbCondDefStrategy;

#include <memory>
#include <vector>

/// This class represents a base class for the Condition/DB proxies
/**
  * The class is meant to be derived by every single proxy loading persistent objects
  * from the Condition/DB. The roles of the class are:
  *
  * - takes respon
  */
template< class T >
class CdbBdbProxyBase : public IfdDataProxyTemplate<T>,
                        public CdbBdbProxyCache {

private:

  /// The copy constructor (NOT IMPLEMENTED)
  /**
    * More details...
    */
    CdbBdbProxyBase( const CdbBdbProxyBase<T>& );

  /// The asignment operator (NOT IMPLEMENTED)
  /**
    * More details...
    */
    CdbBdbProxyBase<T>& operator=( const CdbBdbProxyBase<T>& );

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.
    */
    explicit CdbBdbProxyBase( BdbCondDefStrategy* theStrategy = 0 );

  /// The destructor

    virtual ~CdbBdbProxyBase( );

  /// The ProxyDict fault handler
  /**
    * This method implements the corresponding method defined at the base class
    * or an interface.
    */
    virtual T* faultHandler( IfdProxyDict* theDict,
                             const IfdKey& theKey,
                             AbsArg&       theArg );

  /// The ProxyDict store handler
  /**
    * This method implements the corresponding method defined at the base class
    * or an interface.
    */
    virtual void storeHandler( IfdProxyDict* theDict,
                               const IfdKey& theKey,
                               AbsArg&       theArg,
                               T*            theObject );

  /// The ProxyDict cache tester
  /**
    * This method implements the corresponding method defined at the base class
    * or an interface.
    */
    virtual void testCache( );

protected:

  /// The redefined fault handler
  /**
    * This method is to be implemented by derived classes. It does the actuall
    * job of constructing the transient product of the corresponding proxy.
    *
    * The method is called whenever the persistent cache of the current class is reloaded.
    */
    virtual T* redefinedFaultHandler( const std::vector<CdbBdbProxyElement>& theListOfElements ) = 0;

  /// Return another time to try instead of original one.
  /**
    *  This method is called whenever redefinedFaultHandler return zero pointer.
    *  If this function retuns true then the algorithm repeats with the different
    *  time returned in the anotherTime parameter. Default implementation in this
    *  class always returns false.
    */
    virtual bool tryAnotherTime( const BdbTime&                         theOriginalTime, 
                                 const std::vector<CdbBdbProxyElement>& theListOfElements,
                                 BdbTime&                               TheOtherTime ) ;

  /// Allow access to the cached transient

    T* transientCache( ) { return _transient.get( ); }

  /// Modify the cached transient

    void setTransientCache( T* theNewTransientPtr ) { _transient.reset( theNewTransientPtr ); }

  /// Allow access to the current fault time

    BdbTime faultTime( ) const;

  /// Invalidate the transiniet cache of the proxy

    void invalidateTransientCache( ) { setTransientCache( 0 ); }

  /// Access strategy object

    const BdbCondDefStrategy* strategy( ) const { return _strategy.get( ); }

  /// Modify the strategy object

    void setStrategy( BdbCondDefStrategy* theNewStrategyPtr ) { _strategy.reset( theNewStrategyPtr ); }

private:

  // The strategy

    std::auto_ptr<BdbCondDefStrategy> _strategy;

  // The transient cache

    std::auto_ptr<T> _transient;
    friend class CdbRTestUtility;
};

/// This class specializes a base class for the Condition/DB proxies
/**
  * This specialized version of the proxy base class can be used when
  * condition objects are fetched from the CDB using an explicitly specified
  * revision name and partition identifier rather than relying on configurations
  * of condityions in teh current view.
  *
  * @see CdbBdbProxyBase
  */
template< class T >
class CdbBdbProxyBaseUsingRevision : public CdbBdbProxyBase<T> {

private:

  /// The default constructor (NOT IMPLEMENTED)
  /**
    * More details...
    */
    CdbBdbProxyBaseUsingRevision( );

  /// The copy constructor (NOT IMPLEMENTED)
  /**
    * More details...
    */
    CdbBdbProxyBaseUsingRevision( const CdbBdbProxyBaseUsingRevision<T>& );

  /// The asignment operator (NOT IMPLEMENTED)
  /**
    * More details...
    */
    CdbBdbProxyBaseUsingRevision<T>& operator=( const CdbBdbProxyBaseUsingRevision<T>& );

public:

  /// The normal constructor
  /**
    * A revision to be used by the proxy when finding persistent objects is specified
    * by its name in a scope of a partition. Note, that for the regular conditions
    * the partition identifier is always 0.
    *
    * The last 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.
    */
    explicit CdbBdbProxyBaseUsingRevision( const std::string&  theRevisionName,
                                           unsigned int        thePartitionId = 0,
                                           BdbCondDefStrategy* theStrategy    = 0 );

  /// The destructor

    virtual ~CdbBdbProxyBaseUsingRevision( );

  /// The ProxyDict fault handler
  /**
    * This method overload the default implementations of the same method
    * from the base class.
    *
    * @see CdbBdbProxyBase::faultHandler()
    */
    virtual T* faultHandler( IfdProxyDict* theDict,
                             const IfdKey& theKey,
                             AbsArg&       theArg );

private:

  // The configuration parameters of the proxy

    std::string  _revisionName;
    unsigned int _partitionId;
};


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

#endif  // CDBBDB_PROXY_BASE_HH

---