Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbCond/BdbCondDatabaseBase.hh

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
// File and Version Information:
//      $Id: BdbCondDatabaseBase.hh,v 1.22 2002/06/21 18:46:51 ryd Exp $
//
// Description:
//      Class BdbCondDatabaseBase. 
//      This is the BaBar database manager class.
//      This is a base class from which BdbDatabase is derived.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//      Igor A. Gaponenko           Original author
//
// Copyright Information:
//      Copyright (C) 1994, 1995        Lawrence Berkeley Laboratory
//
//-----------------------------------------------------------------------------

#ifndef BDBCONDDATABASEBASE_HH
#define BDBCONDDATABASEBASE_HH

// -------------------
// -- BaBar Headers --
// -------------------

#include "BaBar/BaBar.hh"

// ----------------------------
// -- BaBar Database Headers --
// ----------------------------

#include "BdbUtil/Bdb.hh"
 
// ---------------
// -- C Headers --
// ---------------

extern "C" {
#include <stddef.h>
}

// ---------------------------------
// -- Collaborating Class Headers --
// ---------------------------------

#include <string>
#include <vector>

#include "BdbCond/BdbIntervalR.hh"
#include "BdbCond/BdbObject.hh"
#include "BdbCond/BdbCondRegistry.hh"
#include "BdbCond/BdbCondRevision.hh"
#include "BdbCond/BdbCondHistory.hh"
#include "BdbCond/BdbCondContainerLink.hh"

// --------------------------------------
// -- Collaborating Class Declarations --
// --------------------------------------

class BdbCondStoreTime;

// ---------------------
// -- Class Interface --
// ---------------------

class BdbCondDatabaseBase {

private:

  // Static data members.

    static std::string _originName;   // This parameter is common for all the instances of this
                                    // class working with the currently open federation.

private:

  // Static initializer for the current origin name.

    static BdbStatus initializeOriginName( );

public:

  /** These accessor functions return requested information from the internal
   ** cache of the object.
   **/

    inline const char* subsystemTLA( )  const;
    inline const char* containerName( ) const;

    inline const BdbHandle(BdbDBObj)&        intervalDBH              ( ) const;
    inline const BdbHandle(BdbContObj)&      intervalContH            ( ) const;
    inline const BdbHandle(BdbCondRegistry)& registryH                ( ) const;
    inline const BdbHandle(BdbCondRevision)& baselineRevisionH        ( ) const;
    inline const BdbHandle(BdbCondRevision)& reviseAfterStoreRevisionH( ) const;
    inline const BdbHandle(BdbCondHistory)&  historyH                 ( ) const;

    inline BdbHandle(BdbDBObj)        getIntervalDBH              ( ) const;
    inline BdbHandle(BdbContObj)      getIntervalContH            ( ) const;
    inline BdbHandle(BdbCondRegistry) getRegistryH                ( ) const;
    inline BdbHandle(BdbCondRevision) getBaselineRevisionH        ( ) const;
    inline BdbHandle(BdbCondRevision) getReviseAfterStoreRevisionH( ) const;
    inline BdbHandle(BdbCondHistory)  getHistoryH                 ( ) const;

    inline void getIntervalDBH              ( BdbHandle(BdbDBObj)&        theIntervalDBH )   const;
    inline void getIntervalContH            ( BdbHandle(BdbContObj)&      theIntervalContH ) const;
    inline void getRegistryH                ( BdbHandle(BdbCondRegistry)& theRegistryH )     const;
    inline void getBaselineRevisionH        ( BdbHandle(BdbCondRevision)& theRevisionH )     const;
    inline void getReviseAfterStoreRevisionH( BdbHandle(BdbCondRevision)& theRevisionH )     const;
    inline void getHistoryH                 ( BdbHandle(BdbCondHistory)&  theHistoryH )      const;

    inline bool isLink( ) const;
    inline bool isWriteLocked( ) const;

    inline BdbCondContainerLink getContainerLink( ) const;

    inline BdbHandle(BdbDBObj)   getLinkDBH  ( ) const;
    inline BdbHandle(BdbContObj) getLinkContH( ) const;

    inline void getContainerLink( BdbCondContainerLink& theLink ) const;

    inline void getLinkDBH  ( BdbHandle(BdbDBObj)&   theLinkDBH )  const;
    inline void getLinkContH( BdbHandle(BdbContObj)& theLinkContH ) const;

  /** Check if the current container is served via a container link.
   **
   ** The function would work silently even if it does not find a link.
   **
   ** The function will always return FALSE for non-linked containers and also
   ** if specified container does not exist yet.
   **
   ** MAY DESTROY THE CACHE.
   **/

    bool isLink( const char* theContainerName );

  /** Check if the current container is available for writing.
   **
   ** The function will return TRUE if it's a linked container and if this container
   ** is locked for wruting.
   **
   ** The function will always return FALSE for non-linked containers and also
   ** if specified container does not exist yet.
   **
   ** MAY DESTROY THE CACHE.
   **/

    bool isWriteLocked( const char* theContainerName );

  /** Locate a registry object for specified container.
   ** This object should always exist in a correct interval container.
   **
   ** MAY RELOAD THE CACHE.
   **/

    BdbStatus findRegistry( BdbHandle(BdbCondRegistry)& theRegistryH,
                            const char*                 theContainerName );

  /** Locate a history object (if any) for a particular interval container.
   ** This history object may not exist for some interval containers.
   **
   ** MAY RELOAD THE CACHE.
   **/

    BdbStatus findHistory( BdbHandle(BdbCondHistory)& theHistoryH,
                           const char*                theContainerName );

  /** Obtain the link description if specified interval container is a link container.
   ** This function would return the success status even if specified interval
   ** container is not the container link.
   **/

    BdbStatus findContainerLink( BdbCondContainerLink& theLink,
                                 const char*           theContainerName );

  /** Return a list of classes with interval containers in this database.
   ** Note that his will NOT clear any existing list members.
   ** The listClasses() method will also ignore any [n] suffixes in the end of container names.
   **
   ** The input parameters are treated in the following way:
   **
   **   useOldIndexes   useLinksOnly  theOriginName
   **
   **        true                                        - containers in old interval database
   **        false          true                         - links in new link database
   **        false          false           0            - containers in new interval database created
   **                                                      in current federation.
   **        false          false           != 0         - containers in new interval database created
   **                                                      in specified federation.
   **/

    BdbStatus listClasses( std::vector<std::string>& theList,
                           bool                           useOldIndexes = false,
                           bool                           useLinksOnly  = true,
                           const char*                    theOriginName = 0 );

    BdbStatus listAllClasses( std::vector<std::string>& theList,
                              bool                           useOldIndexes = false,
                              bool                           useLinksOnly  = true,
                              const char*                    theOriginName = 0 );

protected:

  /** All the constructors, destructor and assignment operator are protected
   ** from a direct use by client's application.
   **/

  // Constructors

    BdbCondDatabaseBase( );
    BdbCondDatabaseBase( const char*                theTLA );
    BdbCondDatabaseBase( const BdbCondDatabaseBase& theDB  );

  // Destructor

    virtual ~BdbCondDatabaseBase( );

  // Operators

    BdbCondDatabaseBase& operator = ( const BdbCondDatabaseBase& theDB );

  /** Locate specified interval conatiner.
   **
   ** The optional parameter, if it's set to FALSE, would return a handle
   ** to the container link only if found and reset internal cache
   ** to invalid state.
   **
   ** If the optional parameter is in their default state  TRUE) the procedure
   ** would locate any (old or new interval container) only and properly set
   ** internal cache of the object in case of success.
   **
   ** MAY RELOAD THE CACHE.
   **/

    BdbStatus findIntervalCont( BdbHandle(BdbContObj)& theIntervalContH,
                                const char*            theContainerName,
                                bool                   followLinkFlag = true );

  /** The following method is ment to create and to initialize the contents of
   ** aspecifiedcontainer link and corresponding interval container.
   **
   ** RELOAD THE CACHE.
   **/

    BdbStatus createIntervalCont( const char*                 theContainerName,
                                  const BdbHandle(BdbObject)& theObjectH,
                                  const BdbTime&              theBeginTime,
                                  const BdbTime&              theEndTime = BdbTime::plusInfinity,
                                  d_ULong                     theTag = 0,
                                  const BdbTime&              theVersionTime = BdbTime::minusInfinity );

  /** Interface to the container History system.
   ** The following methods are ment to write records about differecnt types of activities
   ** affecting the contents of an interval container into the Historian.
   **/

    void historyCCreate( const char* theCode );

    void historyHCreate( const char* theCode,
                         const char* theBackupContName );

    void historyStore( const char*                 theCode,
                       const BdbHandle(BdbObject)& theObjectH,
                       const BdbTime&              theBeginTime,
                       const BdbTime&              theEndTime,
                       d_ULong                     theTag );

    void historyTStore( const char*                 theCode,
                        const BdbHandle(BdbObject)& theObjectH,
                        const BdbTime&              theStoreTime,
                        const BdbTime&              theTruncateTime,
                        d_ULong                     theTag );

    void historyIRemove( const char*                   theCode,
                         const BdbHandle(BdbInterval)& theIntervalH );

    void historyRCreate( const char*                                        theCode,
                         const std::vector<BdbHandle(BdbInterval)>& theList,
                         d_ULong                                            theRevisionBaseId,
                         d_ULong                                            theRevisionId,
                         const char*                                        theRevisionSite,
                         const char*                                        theRevisionDescription );

    void historyRUpdate( const char*                                        theCode,
                         const std::vector<BdbHandle(BdbInterval)>& theList,
                         d_ULong                                            theRevisionId );

    void historyRDelete( const char* theCode,
                         d_ULong     theRevisionId );

    void historyCCopy( const char* theCode,
                       d_ULong     theLastIndex,
                       const char* theDetector,
                       const char* theContainer,
                       d_ULong     theLevel,
                       d_ULong     theRevId,
                       d_Boolean   copyObjects,
                       d_Boolean   copyToLocalDb,
                       const char* theObjectContainer );

    void historyComment( const char* theCode,
                         const char* theComment );

    void historyCPoint( const char*    theCode,
                        const BdbTime& theBackupTime,
                        const char*    theBackupContName );

    void historySplit( const char*    theCode,
                       const BdbTime& theSplitTime,
                       d_ULong        theTag );

    void historyStoreVector( const char*                                 theCode,
                             const std::vector<BdbCondStoreTime>& theVector );

    void historyCMerge( const char*    theCode,
                        const BdbTime& theBeginTime,
                        const BdbTime& theEndTime,
                        const char*    theMergeMethod = "Direct Structural Merge" );

    void historyCPurge( const char*    theCode,
                        const BdbTime& theBeginTime,
                        const BdbTime& theEndTime,
                        d_Boolean      keepRevisedIntervals,
                        d_ULong        maxNumOfTopLayers,
                        d_ULong        maxNumOfLayersUnderRevisedInterval );

    void historyNCorrection( const char*    theCode,
                             const BdbTime& theBeginTime,
                             const BdbTime& theEndTime );

  /** The methods return the "corrected" subsystem and container names if
   ** so called USER AREA is being in use for specified container.
   ** The corrected subsystem & container names might point out into a container
   ** in the different (USER AREA) database.
   **/

    std::string correctedContainerName( const char* theOriginalContainerName );
    std::string correctedSubsystemName( const char* theOriginalContainerName );

  /** Build the system name of the link database for specified
   ** detector.
   **
   ** Specifying the NULL pointer for the origin name would build
   ** the "old"-style name for the interval database, which does not
   ** contain the origin as their part.
   **/

    std::string linkDatabaseName(  const char* theDetector ) const;

    std::string indexDatabaseName( const char* theDetectorName,
                                 const char* theOriginName = 0 ) const;

    std::string buildDatabaseName( bool        useOldIndexes,
                                 bool        useLinksOnly,
                                 const char* theOriginName ) const;

  /** Verify if the current cache is set for specified container.
   ** This function provides more strong checcking than just "reasonable"
   ** check.
   **/

    bool isValidCacheForContainer( const char* theContainerName ) const;

  /** Send a signal to a derived class about reset of the cache
   ** on this level. It's up to the derived class how to process
   ** this signal.
   **/

    virtual void resetCacheHandler( ) = 0;

  /** Explicitly set the internal cache of the object using specified values.
   ** This will also force the cache handler of derived classe(s) to fire.
   **
   ** NOTE: This method provides a very fast way to establish the cache
   **       of this class's instances.
   **/

    void setCache( const char*                       theContainerName,
                   const BdbHandle(BdbDBObj)&        theIntervalDBH,
                   const BdbHandle(BdbContObj)&      theIntervalContH,
                   const BdbHandle(BdbCondRegistry)& theRegistryH,
                   const BdbHandle(BdbCondRevision)& theBaselineRevisionH,
                   const BdbHandle(BdbCondRevision)& theReviseAfterStoreRevisionH,
                   const BdbHandle(BdbCondHistory)&  theHistoryH,
                   bool                              isLink,
                   bool                              isWriteLocked,
                   const BdbCondContainerLink&       link,
                   const BdbHandle(BdbDBObj)&        theLinkDBH,
                   const BdbHandle(BdbContObj)&      theLinkContH );


  /** Reset the internal cache of the object.
   **/

    void resetCache( );

private:

  /** Check if the cache is valid.
   **
   ** NOTE: The cache is considered "valid" if all the data members have
   **       reasonable contents. See the code for the definition of
   **       "reasonable contents".
   **/

    bool isValidCache( ) const;

private:

  // Data members    

    std::string _subsystemTLA;
    std::string _containerNameCache;

    BdbHandle(BdbDBObj)   _intervalDBH;
    BdbHandle(BdbContObj) _intervalContH;

    BdbHandle(BdbCondRegistry) _registryH;
    BdbHandle(BdbCondRevision) _baselineRevisionH;
    BdbHandle(BdbCondRevision) _reviseAfterStoreRevisionH;
    BdbHandle(BdbCondHistory)  _historyH;

    bool _isLink;
    bool _isWriteLocked;

    BdbCondContainerLink _link;

    BdbHandle(BdbDBObj)   _linkDBH;
    BdbHandle(BdbContObj) _linkContH;
};

// -----------------------------------
// -- Inline methods implementation --
// -----------------------------------

inline const char*
BdbCondDatabaseBase::subsystemTLA( ) const
{ return _subsystemTLA.c_str(); }

inline const char*
BdbCondDatabaseBase::containerName( ) const
{ return _containerNameCache.c_str(); }

inline const BdbHandle(BdbDBObj)&
BdbCondDatabaseBase::intervalDBH( ) const
{ return _intervalDBH; }

inline const BdbHandle(BdbContObj)&
BdbCondDatabaseBase::intervalContH( ) const
{ return _intervalContH; }

inline const BdbHandle(BdbCondRegistry)&
BdbCondDatabaseBase::registryH( ) const
{ return _registryH; }

inline const BdbHandle(BdbCondRevision)&
BdbCondDatabaseBase::baselineRevisionH( ) const
{ return _baselineRevisionH; }

inline const BdbHandle(BdbCondRevision)&
BdbCondDatabaseBase::reviseAfterStoreRevisionH( ) const
{ return _reviseAfterStoreRevisionH; }

inline const BdbHandle(BdbCondHistory)&
BdbCondDatabaseBase::historyH( ) const
{ return _historyH; }

inline BdbHandle(BdbDBObj)
BdbCondDatabaseBase::getIntervalDBH( ) const
{ return _intervalDBH; }

inline BdbHandle(BdbContObj)
BdbCondDatabaseBase::getIntervalContH( ) const
{ return _intervalContH; }

inline BdbHandle(BdbCondRegistry)
BdbCondDatabaseBase::getRegistryH( ) const
{ return _registryH; }

inline BdbHandle(BdbCondRevision)
BdbCondDatabaseBase::getBaselineRevisionH( ) const
{ return _baselineRevisionH; }

inline BdbHandle(BdbCondRevision)
BdbCondDatabaseBase::getReviseAfterStoreRevisionH( ) const
{ return _reviseAfterStoreRevisionH; }

inline BdbHandle(BdbCondHistory)
BdbCondDatabaseBase::getHistoryH( ) const
{ return _historyH; }

inline void
BdbCondDatabaseBase::getIntervalDBH( BdbHandle(BdbDBObj)& theIntervalDBH ) const
{ theIntervalDBH = _intervalDBH; }

inline void
BdbCondDatabaseBase::getIntervalContH( BdbHandle(BdbContObj)& theIntervalContH ) const
{ theIntervalContH = _intervalContH; }

inline void
BdbCondDatabaseBase::getRegistryH( BdbHandle(BdbCondRegistry)& theRegistryH ) const
{ theRegistryH = _registryH; }

inline void
BdbCondDatabaseBase::getBaselineRevisionH( BdbHandle(BdbCondRevision)& theRevisionH ) const
{ theRevisionH = _baselineRevisionH; }

inline void
BdbCondDatabaseBase::getReviseAfterStoreRevisionH( BdbHandle(BdbCondRevision)& theRevisionH ) const
{ theRevisionH = _reviseAfterStoreRevisionH; }

inline void
BdbCondDatabaseBase::getHistoryH( BdbHandle(BdbCondHistory)& theHistoryH ) const
{ theHistoryH = _historyH; }

inline bool
BdbCondDatabaseBase::isLink( ) const
{ return _isLink; }

inline bool
BdbCondDatabaseBase::isWriteLocked( ) const
{ return _isWriteLocked; }

inline BdbCondContainerLink
BdbCondDatabaseBase::getContainerLink( ) const
{ return _link; }

inline BdbHandle(BdbDBObj)
BdbCondDatabaseBase::getLinkDBH( ) const
{ return _linkDBH; }

inline BdbHandle(BdbContObj)
BdbCondDatabaseBase::getLinkContH( ) const
{ return _linkContH; }

inline void
BdbCondDatabaseBase::getContainerLink( BdbCondContainerLink& theLink ) const
{ theLink = _link; }

inline void
BdbCondDatabaseBase::getLinkDBH( BdbHandle(BdbDBObj)& theLinkDBH ) const
{ theLinkDBH = _linkDBH; }

inline void
BdbCondDatabaseBase::getLinkContH( BdbHandle(BdbContObj)& theLinkContH ) const
{ theLinkContH = _linkContH; }

#endif /* BDBCONDDATABASEBASE_HH */

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002