---

CdbProxyBase.hh

Go to the documentation of this file.

#ifndef CDB_PROXY_BASE_HH
#define CDB_PROXY_BASE_HH

// File and Version Information:
//      $Id: CdbProxyBase.hh,v 1.2 2005/07/13 20:00:58 jtinslay Exp $

#include "CdbBase/CdbProxyCache.hh"
#include "ProxyDict/IfdDataProxyTemplate.hh"

class CdbDefStrategy;

#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 CdbProxyBase : public IfdDataProxyTemplate<T>,
                     public CdbProxyCache {

private:

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

  /// The asignment operator (NOT IMPLEMENTED)
  /**
    * More details...
    */
    CdbProxyBase<T>& operator=( const CdbProxyBase<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 CdbProxyBase( CdbDefStrategy* theStrategy = 0 );

  /// The destructor

    virtual ~CdbProxyBase( );

  /// 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<CdbProxyElement>& 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<CdbProxyElement>& 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 CdbDefStrategy* strategy( ) const { return _strategy.get( ); }

  /// Modify the strategy object

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

private:

  // The strategy

    std::auto_ptr<CdbDefStrategy> _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 CdbProxyBase
  */
template< class T >
class CdbProxyBaseUsingRevision : public CdbProxyBase<T> {

private:

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

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

  /// The asignment operator (NOT IMPLEMENTED)
  /**
    * More details...
    */
    CdbProxyBaseUsingRevision<T>& operator=( const CdbProxyBaseUsingRevision<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 CdbProxyBaseUsingRevision( const std::string& theRevisionName,
                                        unsigned int       thePartitionId = 0,
                                        CdbDefStrategy*    theStrategy    = 0 );

  /// The destructor

    virtual ~CdbProxyBaseUsingRevision( );

  /// The ProxyDict fault handler
  /**
    * This method overload the default implementations of the same method
    * from the base class.
    *
    * @see CdbProxyBase::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 "CdbBase/CdbProxyBase.cc"
#endif  // BABAR_COMP_INST

#endif  // CDB_PROXY_BASE_HH

---