---

CdbBdbWDatabase.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbWDatabase.cc,v 1.18 2005/08/13 01:24:43 gapon Exp $

/// The implementation of the CdbBdbWDatabase class.
/**
  * @see CdbBdbWDatabase
  */
#include "BaBar/BaBar.hh"

#include "CdbBdbWrapper/CdbBdbWDatabase.hh"

#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbView.hh"
#include "CdbBase/CdbId.hh"
#include "CdbBase/CdbCompositeName.hh"
#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/CdbPartition.hh"
#include "CdbBase/CdbProperty.hh"
#include "CdbBase/CdbOrigin.hh"

#include "CdbBdbWrapper/CdbBdbWView.hh"
#include "CdbBdbWrapper/CdbBdbWViewItr.hh"

#include "ErrLogger/ErrLog.hh"

#include <string.h>
using std::endl;

namespace {

///////////////////////////////
// Class CdbBdbWPartitionItr //
///////////////////////////////

/// The wrapper implementation of a transient partition iterator
/**
  * This is an empty collection iterator sine there is no
  * partitions in the 'Wraper' implementation.
  */
class CdbBdbWPartitionItr : public CdbIItr<unsigned short> {

public:

  /// The default constructor
  /**
    */
    CdbBdbWPartitionItr( );

  /// The copy constructor
  /**
    * More details to come...
    */
    CdbBdbWPartitionItr( const CdbBdbWPartitionItr& theItr );

  /// The assignment operator
  /**
    * More details to come...
    */
    CdbBdbWPartitionItr& operator=( const CdbBdbWPartitionItr& theItr );

  /// The destructor
  /**
    * Details...
    */
    virtual ~CdbBdbWPartitionItr( );

  /// Reset an iterator to its initial state.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::reset
    * @see CdbStatus
    */
    virtual CdbStatus reset( );

  /// Advance an iterator to the next position.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::next()
    */
    virtual bool next( );

  /// Obtain the currently reffered value.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::value()
    *
    * @return the current value the iterator is set on
    */
    virtual unsigned short value( );

  /// Check if an iterator is valid.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::isValid()
    */
    virtual bool isValid( );

  /// Make a clone of itself
  /**
    * @see CdbIItr::clone()
    */
    virtual CdbIItr<unsigned short>* clone( ) const;
};

CdbBdbWPartitionItr::CdbBdbWPartitionItr( )
{ }

CdbBdbWPartitionItr::CdbBdbWPartitionItr( const CdbBdbWPartitionItr& theItr )
{ }

CdbBdbWPartitionItr::~CdbBdbWPartitionItr( )
{ }

CdbBdbWPartitionItr&
CdbBdbWPartitionItr::operator=( const CdbBdbWPartitionItr& theItr )
{
    return *this;
}

CdbStatus
CdbBdbWPartitionItr::reset( )
{
    return CdbStatus::Success;
}

bool
CdbBdbWPartitionItr::next( )
{
  // There are no elements in this collection.

    return false;
}

unsigned short
CdbBdbWPartitionItr::value( )
{
    ErrMsg(fatal) << "this function should never been called." << endmsg;
    return 0;
}

bool
CdbBdbWPartitionItr::isValid( )
{
    return false;
}

CdbIItr<unsigned short>*
CdbBdbWPartitionItr::clone( ) const
{
    return new CdbBdbWPartitionItr( *this );
}

////////////////////////////
// Class CdbBdbWOriginItr //
////////////////////////////

/// The wrapper implementation of a transient origin iterator
/**
  * This is the "one-element" collection iterator sine there is just one
  * origin object in the 'Wraper' implementation. The iterator when successfully
  * advanced will return 0 value.
  */
class CdbBdbWOriginItr : public CdbIItr<unsigned short> {

public:

  /// The default constructor
  /**
    */
    CdbBdbWOriginItr( );

  /// The copy constructor
  /**
    * More details to come...
    */
    CdbBdbWOriginItr( const CdbBdbWOriginItr& theItr );

  /// The assignment operator
  /**
    * More details to come...
    */
    CdbBdbWOriginItr& operator=( const CdbBdbWOriginItr& theItr );

  /// The destructor
  /**
    * Details...
    */
    virtual ~CdbBdbWOriginItr( );

  /// Reset an iterator to its initial state.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::reset
    * @see CdbStatus
    */
    virtual CdbStatus reset( );

  /// Advance an iterator to the next position.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::next()
    */
    virtual bool next( );

  /// Obtain the currently reffered value.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::value()
    *
    * @return the current value the iterator is set on
    */
    virtual unsigned short value( );

  /// Check if an iterator is valid.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::isValid()
    */
    virtual bool isValid( );

  /// Make a clone of itself
  /**
    * @see CdbIItr::clone()
    */
    virtual CdbIItr<unsigned short>* clone( ) const;

private:

    bool _isValid;
    bool _hasEverBeenAdvanced;
};

CdbBdbWOriginItr::CdbBdbWOriginItr( ) :
    _isValid(false),
    _hasEverBeenAdvanced(false)
{ }

CdbBdbWOriginItr::CdbBdbWOriginItr( const CdbBdbWOriginItr& theItr ) :
    _isValid(theItr._isValid),
    _hasEverBeenAdvanced(theItr._hasEverBeenAdvanced)
{ }

CdbBdbWOriginItr::~CdbBdbWOriginItr( )
{ }

CdbBdbWOriginItr&
CdbBdbWOriginItr::operator=( const CdbBdbWOriginItr& theItr )
{
    if( &theItr != this ) {
        _isValid             = theItr._isValid;
        _hasEverBeenAdvanced = theItr._hasEverBeenAdvanced;
    }
    return *this;
}

CdbStatus
CdbBdbWOriginItr::reset( )
{
    _isValid             = false;
    _hasEverBeenAdvanced = false;

    return CdbStatus::Success;
}

bool
CdbBdbWOriginItr::next( )
{
    if( _isValid ) {
        _isValid             = false;
    } else {
        _isValid             = true;
        _hasEverBeenAdvanced = true;
    }
    return _isValid;
}

unsigned short
CdbBdbWOriginItr::value( )
{
    if( !isValid( )) ErrMsg(fatal) << "attempting to use a non-initialized iterator." << endmsg;
    return 0;
}

bool
CdbBdbWOriginItr::isValid( )
{
    return _isValid;
}

CdbIItr<unsigned short>*
CdbBdbWOriginItr::clone( ) const
{
    return new CdbBdbWOriginItr( *this );
}

////////////////////////////////////
// Class CdbBdbWOriginPropertyItr //
////////////////////////////////////

/// The wrapper implementation of a transient origin's property iterator
/**
  * This is an empty collection iterator sine there is no
  * properties at the origin of the 'Wraper' implementation.
  */
class CdbBdbWOriginPropertyItr : public CdbIItr<CdbProperty> {

public:

  /// The default constructor
  /**
    */
    CdbBdbWOriginPropertyItr( );

  /// The copy constructor
  /**
    * More details to come...
    */
    CdbBdbWOriginPropertyItr( const CdbBdbWOriginPropertyItr& theItr );

  /// The assignment operator
  /**
    * More details to come...
    */
    CdbBdbWOriginPropertyItr& operator=( const CdbBdbWOriginPropertyItr& theItr );

  /// The destructor
  /**
    * Details...
    */
    virtual ~CdbBdbWOriginPropertyItr( );

  /// Reset an iterator to its initial state.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::reset
    * @see CdbStatus
    */
    virtual CdbStatus reset( );

  /// Advance an iterator to the next position.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::next()
    */
    virtual bool next( );

  /// Obtain the currently reffered value.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::value()
    *
    * @return the current value the iterator is set on
    */
    virtual CdbProperty value( );

  /// Check if an iterator is valid.
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbIItr::isValid()
    */
    virtual bool isValid( );

  /// Make a clone of itself
  /**
    * @see CdbIItr::clone()
    */
    virtual CdbIItr<CdbProperty>* clone( ) const;
};

CdbBdbWOriginPropertyItr::CdbBdbWOriginPropertyItr( )
{ }

CdbBdbWOriginPropertyItr::CdbBdbWOriginPropertyItr( const CdbBdbWOriginPropertyItr& theItr )
{ }

CdbBdbWOriginPropertyItr::~CdbBdbWOriginPropertyItr( )
{ }

CdbBdbWOriginPropertyItr&
CdbBdbWOriginPropertyItr::operator=( const CdbBdbWOriginPropertyItr& theItr )
{
    return *this;
}

CdbStatus
CdbBdbWOriginPropertyItr::reset( )
{
    return CdbStatus::Success;
}

bool
CdbBdbWOriginPropertyItr::next( )
{
  // There are no elements in this collection.

    return false;
}

CdbProperty
CdbBdbWOriginPropertyItr::value( )
{
    ErrMsg(fatal) << "this function should never been called." << endmsg;
    return CdbProperty( );
}

bool
CdbBdbWOriginPropertyItr::isValid( )
{
    return false;
}

CdbIItr<CdbProperty>*
CdbBdbWOriginPropertyItr::clone( ) const
{
    return new CdbBdbWOriginPropertyItr( *this );
}

/////////////////////////
// Class CdbBdbWOrigin //
/////////////////////////

/// The wrapper implementation of a transient origin
/**
  * This is the only "origin" of the 'Wraper' implementation.
  */
class CdbBdbWOrigin : public CdbOrigin {

public:

private:

  /// The constructor (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbBdbWOrigin( );

  /// The copy constructor (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbBdbWOrigin( const CdbBdbWOrigin& theOrigin );

  /// The assignment operator (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbBdbWOrigin& operator=( const CdbBdbWOrigin& theOrigin );

public:

  /// The normal constructor.
  /**
    * Initialize context with specified parameters.
    *
    * @see CdbDatabase
    * @see CdbDatabasePtr
    */
    CdbBdbWOrigin( const CdbDatabasePtr& theDatabasePtr /**< the smart pointer providing a back back link to the parent database object */
                 );

  /// The destructor.
  /**
    * More details...
    */
    virtual ~CdbBdbWOrigin( );

  /// Obtain the creation time of the origin
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::created()
    */
    virtual BdbTime created( );

  /// Obtain the origin description
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::description()
    */
    virtual std::string description( );

  /// Check if this origin is the local one
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::isLocal()
    */
    virtual bool isLocal( ) const;

  /// Check if data corresponding to this origin are available in the local database
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::isInstantiated()
    */
    virtual bool isInstantiated( ) const;

  /// Check if this origin is the "master" one
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::isMaster()
    */
    virtual bool isMaster( ) const;

  /// Check if this origin is a "slave" one
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::isSlave()
    */
    virtual bool isSlave( ) const;

  /// Check if this origin is a "test" one
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::isTest()
    */
    virtual bool isTest( ) const;

  /// Set up an iterator of properties
  /**
    * This implements the corresponding method of the base class.
    *
    * @see CdbOrigin::propertyIterator()
    */
    virtual CdbStatus propertyIterator( CdbItr<CdbProperty>& theItr );
};

CdbBdbWOrigin::CdbBdbWOrigin( const CdbDatabasePtr& theDatabasePtr ) :
    CdbOrigin( theDatabasePtr,
               "<local>",
               0 )
{ }

CdbBdbWOrigin::~CdbBdbWOrigin( )
{ }

BdbTime
CdbBdbWOrigin::created( )
{
    return BdbTime::minusInfinity;
}

std::string
CdbBdbWOrigin::description( )
{
    return std::string( "<not available in current implementation>" );
}

bool
CdbBdbWOrigin::isLocal( ) const
{
    return true;
}

bool
CdbBdbWOrigin::isInstantiated( ) const
{
    return true;
}

bool
CdbBdbWOrigin::isMaster( ) const
{
    return true;
}

bool
CdbBdbWOrigin::isSlave( ) const
{
    return false;
}

bool
CdbBdbWOrigin::isTest( ) const
{
    return false;
}

CdbStatus
CdbBdbWOrigin::propertyIterator( CdbItr<CdbProperty>& theItr )
{
  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    theItr = CdbItr<CdbProperty>( new CdbBdbWOriginPropertyItr( ));

    return CdbStatus::Success;
}

};

///////////////////////////
// Class CdbBdbWDatabase //
///////////////////////////

CdbDatabase*
CdbBdbWDatabase::clone( ) const
{
  // Get rid of the "const" to access non-const methods

    CdbBdbWDatabase* mySelf = const_cast<CdbBdbWDatabase*>( this );
    return new CdbBdbWDatabase( mySelf->parent( ),
                                mySelf->name( ));
}

CdbBdbWDatabase::CdbBdbWDatabase( const CdbPtr& theCdbPtr,
                                  const char*   theName ) :
    CdbDatabase( theCdbPtr,
                 theName )
{ }

CdbBdbWDatabase::~CdbBdbWDatabase( )
{ }

bool
CdbBdbWDatabase::isValid( )
{
    return true;
}

bool
CdbBdbWDatabase::isOpen( )
{
    return true;
}

CdbStatus
CdbBdbWDatabase::open( )
{
    return CdbStatus::Success;
}

CdbStatus
CdbBdbWDatabase::close( )
{
    return CdbStatus::Success;
}

BdbTime
CdbBdbWDatabase::id( )
{
    return BdbTime::minusInfinity;
}


BdbTime
CdbBdbWDatabase::created( )
{
    return BdbTime::minusInfinity;
}

std::string
CdbBdbWDatabase::description( )
{
    return std::string( "<not available in current implementation>" );
}

std::string
CdbBdbWDatabase::defaultView( ) const
{
    return CdbEnvironment::defaultView( parent( )->technologyName( ),
                                        parent( )->implementationName( ),
                                        name( ));
}

CdbStatus
CdbBdbWDatabase::findView( CdbViewPtr& thePtr,
                           const char* theName )
{
    CdbStatus result = CdbStatus::Error;

    thePtr = 0;

    do {

      // Verify and correct parameters if 0 pointer is passed to indicate
      // that default database is needed.

        std::string viewName = defaultView( );
        if( 0 != theName ) viewName = theName;

        if( viewName != defaultView( )) {

            ErrMsg(error) << "no such view in this implementation: \"" << viewName << "\"" << endl
                          << "The only name allowed is the default one: \"" << defaultView( ) << "\"" << endmsg;

            break;
        }

      // DESIGN NOTE: We need to construct a smart pointer against a clone since
      //              we don't know a smart pointer pointing to the current
      //              instance, therefore we can't guarantee the lifetime
      //              of the current instance.
      //
      // NOTE: The above corrected parameters object is used.

        CdbDatabasePtr myPtr( this->clone( ));

        thePtr = new CdbBdbWView( myPtr,
                                  viewName.c_str( ));

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbWDatabase::findView( CdbViewPtr&  thePtr,
                           const CdbId& theId )
{
  // IMPLEMENTATION NOTE: Since the only view available in the "Wrapper"
  //                      implementation is the default one then we're
  //                      dispatching this call down to that default view.

    return findView( thePtr,
                     defaultView( ).c_str( ));
}

CdbStatus
CdbBdbWDatabase::viewIterator( CdbViewItr& theItr )
{
    CdbDatabasePtr myPtr = this->clone( );

  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    theItr = CdbViewItr( new CdbBdbWViewItr( myPtr ));

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWDatabase::physicalConditionIterator( CdbItr<CdbId>& theItr )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbBdbWDatabase::findCondition( CdbConditionPtr& thePtr,
                                const CdbId&     theId )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbBdbWDatabase::findCondition( CdbConditionPtr&        thePtr,
                                const CdbCompositeName& thePhysicalName )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbBdbWDatabase::historyEventIterator( CdbHistoryEventItr& theItr,
                                       const BdbTime&      theBeginTime,
                                       const BdbTime&      theEndTime,
                                       const char**        theEventsToSelect )
{
    return CdbStatus::Error;
}

CdbStatus
CdbBdbWDatabase::historyEventTypeIterator( CdbHistoryEventTypeItr& theItr )
{
    return CdbStatus::Error;
}

CdbStatus
CdbBdbWDatabase::partitionIterator( CdbItr<unsigned short>& theItr )
{
  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    theItr = CdbItr<unsigned short>( new CdbBdbWPartitionItr( ));

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWDatabase::partitionIterator( CdbItr<unsigned short>& theItr,
                                    unsigned int            theOriginId )
{
  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    theItr = CdbItr<unsigned short>( new CdbBdbWPartitionItr( ));

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWDatabase::partitionIterator( CdbItr<unsigned short>& theItr,
                                    const char*             theOriginName )
{
  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    theItr = CdbItr<unsigned short>( new CdbBdbWPartitionItr( ));

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWDatabase::findPartition( CdbPartitionPtr& thePtr,
                                unsigned short   thePartition )
{
  // No partitions exist in this implementation

    return CdbStatus::NotFound;
}

CdbStatus
CdbBdbWDatabase::findPartition( CdbPartitionPtr& thePtr,
                                unsigned short   thePartition,
                                unsigned int     theOriginId )
{
  // No partitions exist in this implementation

    return CdbStatus::NotFound;
}

CdbStatus
CdbBdbWDatabase::findPartition( CdbPartitionPtr& thePtr,
                                unsigned short   thePartition,
                                const char*      theOriginName )
{
  // No partitions exist in this implementation

    return CdbStatus::NotFound;
}

CdbOriginPtr
CdbBdbWDatabase::localOrigin( )
{
  // DESIGN NOTE: We need to construct a smart pointer against a clone since
  //              we don't know a smart pointer pointing to the current
  //              instance, therefore we can't guarantee the lifetime
  //              of the current instance.
  //
  // NOTE: The above corrected parameters object is used.

    CdbDatabasePtr myPtr( this->clone( ));

    return new CdbBdbWOrigin( myPtr );
}

CdbStatus
CdbBdbWDatabase::originIterator( CdbItr<unsigned short>& theItr )
{
  // ATTENTION: This is not a memory leak - the created object
  //            will be destroyed by the iterator.

    theItr = CdbItr<unsigned short>( new CdbBdbWOriginItr( ));

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWDatabase::findOrigin( CdbOriginPtr& thePtr,
                             const char*   theName )
{
    CdbStatus result = CdbStatus::NotFound;
    do {

      // Only this origin is allowed in thsi implementation

        if( 0 != strcmp( "<local>", theName )) break;

      // DESIGN NOTE: We need to construct a smart pointer against a clone since
      //              we don't know a smart pointer pointing to the current
      //              instance, therefore we can't guarantee the lifetime
      //              of the current instance.
      //
      // NOTE: The above corrected parameters object is used.

        CdbDatabasePtr myPtr( this->clone( ));

        thePtr = new CdbBdbWOrigin( myPtr );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbWDatabase::findOrigin( CdbOriginPtr&  thePtr,
                             unsigned short theId )
{
    CdbStatus result = CdbStatus::NotFound;
    do {

      // Only this origin is allowed in thsi implementation

        if( 0 != theId ) break;

      // DESIGN NOTE: We need to construct a smart pointer against a clone since
      //              we don't know a smart pointer pointing to the current
      //              instance, therefore we can't guarantee the lifetime
      //              of the current instance.
      //
      // NOTE: The above corrected parameters object is used.

        CdbDatabasePtr myPtr( this->clone( ));

        thePtr = new CdbBdbWOrigin( myPtr );

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

/////////////////
// End Of File //
/////////////////

---