---

CdbCondition.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbCondition.cc,v 1.23 2005/09/15 05:04:10 gapon Exp $

/// The implementation of the CdbCondition class.
/**
  * @see CdbCondition
  */

#include "BaBar/BaBar.hh"

#include "CdbBase/CdbCondition.hh"

#include "CdbBase/CdbDatabase.hh"
#include "CdbBase/CdbView.hh"
#include "CdbBase/CdbFolder.hh"
#include "CdbBase/CdbObject.hh"
#include "CdbBase/CdbRevision.hh"
#include "CdbBase/CdbRevisionPolicy.hh"
#include "CdbBase/CdbPathName.hh"
#include "CdbBase/CdbObjectFactoryBase.hh"
#include "CdbBase/CdbId.hh"
#include "CdbBase/CdbCompositeName.hh"

#include "ErrLogger/ErrLog.hh"
using std::endl;

CdbStatus
CdbCondition::instance( CdbConditionPtr& theConditionPtr,
                        const char*      theFullPathName,
                        const char*      theViewName,
                        const char*      theDatabaseName,
                        const char*      theImplementationName,
                        const char*      theTechnologyName )
{
    CdbStatus result = CdbStatus::Error;

    theConditionPtr = 0;

    do {

      // Evaluate extended parameters of a condition to be found

        CdbPathName fullPathName( theFullPathName );
        if( ! fullPathName.isValid( ) ||
            ! fullPathName.isAbsolute( ) ||
            fullPathName.isRoot( )) {

            ErrMsg(error) << "Invalid value of the condition's full path name passed to the procedure." << endl
                          << "    PASSED NAME: \"" << theFullPathName << "\"" << endl
                          << "A non-empty non-'root' 'absolute' path name was expected." << endmsg;
            break;
        }

      // Find a folder

        CdbFolderPtr folderPtr;
        if( CdbStatus::Success != CdbFolder::instance( folderPtr,
                                                       fullPathName.beforeLast( ).toString( ).c_str( ),
                                                       theViewName,
                                                       theDatabaseName,
                                                       theImplementationName,
                                                       theTechnologyName )) break;

      // Locate a condition in the scope of the found folder.

        result = folderPtr->findCondition( theConditionPtr,
                                           fullPathName.last( ).toString( ).c_str( ));

    } while( false );

    return result;
}

CdbStatus
CdbCondition::instance( CdbConditionPtr& theConditionPtr,
                        const char*      theFullPathName,
                        const CdbId&     theViewId,
                        const char*      theDatabaseName,
                        const char*      theImplementationName,
                        const char*      theTechnologyName )
{
    CdbStatus result = CdbStatus::Error;

    theConditionPtr = 0;

    do {

      // Evaluate extended parameters of a condition to be found

        CdbPathName fullPathName( theFullPathName );
        if( ! fullPathName.isValid( ) ||
            ! fullPathName.isAbsolute( ) ||
            fullPathName.isRoot( )) {

            ErrMsg(error) << "Invalid value of the condition's full path name passed to the procedure." << endl
                          << "    PASSED NAME: \"" << theFullPathName << "\"" << endl
                          << "A non-empty non-'root' 'absolute' path name was expected." << endmsg;
            break;
        }

      // Find a folder

        CdbFolderPtr folderPtr;
        if( CdbStatus::Success != CdbFolder::instance( folderPtr,
                                                       fullPathName.beforeLast( ).toString( ).c_str( ),
                                                       theViewId,
                                                       theDatabaseName,
                                                       theImplementationName,
                                                       theTechnologyName )) break;

      // Locate a condition in the scope of the found folder.

        result = folderPtr->findCondition( theConditionPtr,
                                           fullPathName.last( ).toString( ).c_str( ));

    } while( false );

    return result;
}

CdbStatus
CdbCondition::instance( CdbConditionPtr& theConditionPtr,
                        const CdbId&     thePhysicalAddress,
                        const char*      theDatabaseName,
                        const char*      theImplementationName,
                        const char*      theTechnologyName )
{
    CdbStatus result = CdbStatus::Error;

    theConditionPtr = 0;

    do {

      // Find a database

        CdbDatabasePtr databasePtr;
        if( CdbStatus::Success != CdbDatabase::instance( databasePtr,
                                                         theDatabaseName,
                                                         theImplementationName,
                                                         theTechnologyName )) break;

      // Locate a physical condition in the scope of the found database.

        result = databasePtr->findCondition( theConditionPtr,
                                             thePhysicalAddress );

    } while( false );

    return result;
}

CdbStatus
CdbCondition::instance( CdbConditionPtr&        theConditionPtr,
                        const CdbCompositeName& thePhysicalName,
                        const char*             theDatabaseName,
                        const char*             theImplementationName,
                        const char*             theTechnologyName )
{
    CdbStatus result = CdbStatus::Error;

    theConditionPtr = 0;

    do {

      // Find a database

        CdbDatabasePtr databasePtr;
        if( CdbStatus::Success != CdbDatabase::instance( databasePtr,
                                                         theDatabaseName,
                                                         theImplementationName,
                                                         theTechnologyName )) break;

      // Locate a physical condition in the scope of the found database.

        result = databasePtr->findCondition( theConditionPtr,
                                             thePhysicalName );

    } while( false );

    return result;
}

CdbStatus
CdbCondition::instanceFromAny( CdbConditionPtr& theConditionPtr,
                               const char*      theConditionName,
                               const char*      theDatabaseName,
                               const char*      theImplementationName,
                               const char*      theTechnologyName )
{
  // Try 'physical' address or name first

    CdbCompositeName physicalName( theConditionName );
    if( physicalName.isValid( )) {

        CdbId physicalAddress;
        if( CdbId::translate( physicalAddress,
                              physicalName )) {

          // Locate a condition by its 'physical address'

            return instance( theConditionPtr,
                             physicalAddress,
                             theDatabaseName,
                             theImplementationName,
                             theTechnologyName );

        } else {

          // Locate a condition by its 'physical name'

            return instance( theConditionPtr,
                             physicalName,
                             theDatabaseName,
                             theImplementationName,
                             theTechnologyName );
        }
    }

  // Assume that the condition was specified by its path in a view

    return instance( theConditionPtr,
                     theConditionName,
                     theDatabaseName,
                     theImplementationName,
                     theTechnologyName );
}

std::string
CdbCondition::fullPathName( const CdbConditionPtr& theConditionPtr )
{
    if( theConditionPtr.isNull( )) return std::string( "" );

  // Note, that a condition found by its 'physical' address or name does not
  // have a valid "full path", which would only make sense in a view.

    if( theConditionPtr->parent( ).isNull( )) return std::string( "" );

  // Proceed for conditions found through a view

    CdbPathName result( theConditionPtr->name( ));

    CdbFolderPtr parentFolder = theConditionPtr->parent( );
    while( !parentFolder.isNull( )) {
        result = CdbPathName( parentFolder->name( )) + result;
        parentFolder = parentFolder->parentFolder( );
    }
    return result.toString( );
}

CdbCondition::CdbCondition( const CdbFolderPtr&   theFolderPtr,
                            const CdbDatabasePtr& theDatabasePtr,
                            const char*           theName ) :
    _myParent        (theFolderPtr),
    _myParentDatabase(theDatabasePtr),
    _myName          (theName)
{
    if( theDatabasePtr.isNull( )) ErrMsg(fatal) << "null database pointer passed to the constructor." << endmsg;
    if( 0 == theName )            ErrMsg(fatal) << "empty condition name string passed to the constructor." << endmsg;
}

CdbCondition::CdbCondition( const CdbCondition& theCondition ) :
    _myParent        (theCondition._myParent),
    _myParentDatabase(theCondition._myParentDatabase),
    _myName          (theCondition._myName)
{ }

CdbCondition::~CdbCondition( )
{ }

CdbCondition&
CdbCondition::operator=( const CdbCondition& theCondition )
{
    if( this != &theCondition ) {
        _myParent         = theCondition._myParent;
        _myParentDatabase = theCondition._myParentDatabase;
        _myName           = theCondition._myName;
    }
    return *this;
}

const CdbFolderPtr&
CdbCondition::parent( ) const
{
    return _myParent;
}

const CdbDatabasePtr&
CdbCondition::parentDatabase( ) const
{
    return _myParentDatabase;
}

const char*
CdbCondition::name( ) const
{
    return _myName.c_str( );
}

CdbStatus
CdbCondition::storeObject( CdbObjectFactoryBase& theObjectFactory,
                           const BdbTime&        theBegin,
                           const BdbTime&        theEnd )
{
    CdbObjectPtr oPtr;
    return storeObject( theObjectFactory,
                        theBegin,
                        theEnd,
                        oPtr );
}

CdbStatus
CdbCondition::storeAndTruncateObject( CdbObjectFactoryBase& theObjectFactory,
                                      const BdbTime&        theStoreTime,
                                      const BdbTime&        theTruncateTime )
{
    CdbObjectPtr oPtr;
    return storeAndTruncateObject( theObjectFactory,
                                   theStoreTime,
                                   theTruncateTime,
                                   oPtr );
}

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

---