---

CdbEnvironmentImpl.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbEnvironmentImpl.cc,v 1.16 2005/11/03 02:49:26 gapon Exp $

/// The implementation of the CdbEnvironmentImplImpl singleton.
/**
  * @see CdbEnvironmentImpl
  */

#include "BaBar/BaBar.hh"

#include "CdbBase/CdbEnvironmentImpl.hh"
#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbDebugStream.hh"

#include <stdio.h>
#include <string.h>    // strcmp()
#include <assert.h>

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

CdbEnvironmentImpl::CdbEnvironmentImpl( ) :
    _truncateTime(BdbTime::plusInfinity),
    _defaultTechnologyName("")
{ }

CdbEnvironmentImpl::CdbEnvironmentImpl( const CdbEnvironmentImpl& theOther ) :
    _truncateTime         (theOther._truncateTime),
    _technologies         (theOther._technologies),
    _defaultTechnologyName(theOther._defaultTechnologyName)
{ }

CdbEnvironmentImpl::~CdbEnvironmentImpl( )
{ }

CdbEnvironmentImpl&
CdbEnvironmentImpl::operator=( const CdbEnvironmentImpl& theOther )
{
    if( this != &theOther ) {
        _truncateTime          = theOther._truncateTime;
        _technologies          = theOther._technologies;
        _defaultTechnologyName = theOther._defaultTechnologyName;
    }
    return *this;
}

BdbTime
CdbEnvironmentImpl::getTruncateTime( )
{
    return _truncateTime;
}

BdbTime
CdbEnvironmentImpl::setTruncateTime( const BdbTime& theNewTruncateTime )
{
    if( BdbTime::minusInfinity == theNewTruncateTime )
        ErrMsg(fatal) << "Incorrect value passed to the procedure. The current application" << endl
                      << "may be misconfigured. A memory corruption may also take place." << endmsg;

    BdbTime previous = _truncateTime;
    _truncateTime = theNewTruncateTime;

    CDB_DEBUG_STREAM << "Condition/DB API truncate time set to " << _truncateTime << endl;

    return _truncateTime;
}

CdbStatus
CdbEnvironmentImpl::getDefaultTechnology( std::string& theTechnologyName )
{
  // Make sure the underlying implementations of CDB API registered
  // in the dictionary are properly initialized.

    initialize( );

  // Check if there is the one

    if( 0 == _technologies.size( )) return CdbStatus::NotFound;

    assert( "" != _defaultTechnologyName ); // Inconsistent state of the internal data structures of
                                            // the current class.

  // Done

    theTechnologyName = _defaultTechnologyName;

    return CdbStatus::Success;
}

CdbStatus
CdbEnvironmentImpl::getDefaultImplementation( std::string& theImplementationName,
                                              const char*  theTechnologyName )
{
  // Make sure the underlying implementations of CDB API registered
  // in the dictionary are properly initialized.

    initialize( );

  // Make adjustment to the technology.

    std::string technologyName;
    {
        CdbStatus status = translateAndVerify( technologyName,
                                               theTechnologyName );
        if     ( CdbStatus::Success  == status ) ;
        else if( CdbStatus::NotFound == status ) return status;
        else {
            ErrMsg(error) << "Failed to translate the parameters of CDB API passed to the procedure." << endl
                          << "The current application may be misconfigured." << endmsg;
            return CdbStatus::Error;
        }
    }

  // Now try to get the default implementation in the scope of found
  // technology object.

    CdbPtr implementationPtr;
    if( !(_technologies[technologyName].getDefault( implementationPtr ))) return CdbStatus::NotFound;

    assert( !implementationPtr.isNull( ));  // Inconsistent state of the internal data structures of
                                            // the current class.

  // Done

    theImplementationName = implementationPtr->implementationName( );

    return CdbStatus::Success;
}

CdbStatus
CdbEnvironmentImpl::getDefaultDatabase( std::string& theDatabaseName,
                                        const char*  theImplementationName,
                                        const char*  theTechnologyName )
{
  // Make sure the underlying implementations of CDB API registered
  // in the dictionary are properly initialized.

    initialize( );

  // Make adjustment to the technology.& implementation

    std::string technologyName;
    std::string implementationName;
    CdbPtr      implementationPtr;
    {
        CdbStatus status = translateAndVerify( technologyName,
                                               implementationName,
                                               implementationPtr,
                                               theTechnologyName,
                                               theImplementationName );
        if     ( CdbStatus::Success  == status ) ;
        else if( CdbStatus::NotFound == status ) return status;
        else {
            ErrMsg(error) << "Failed to translate the parameters of CDB API passed to the procedure." << endl
                          << "The current application may be misconfigured." << endmsg;
            return CdbStatus::Error;
        }
    }

  // Finish

    return implementationPtr->getDefaultDatabase( theDatabaseName );
}

CdbStatus
CdbEnvironmentImpl::getDefaultView( std::string& theViewName,
                                    const char*  theDatabaseName,
                                    const char*  theImplementationName,
                                    const char*  theTechnologyName )
{
  // Make sure the underlying implementations of CDB API registered
  // in the dictionary are properly initialized.

    initialize( );

  // Make adjustment to the technology.& implementation

    std::string technologyName;
    std::string implementationName;
    CdbPtr      implementationPtr;
    {
        CdbStatus status = translateAndVerify( technologyName,
                                               implementationName,
                                               implementationPtr,
                                               theTechnologyName,
                                               theImplementationName );
        if     ( CdbStatus::Success  == status ) ;
        else if( CdbStatus::NotFound == status ) return status;
        else {
            ErrMsg(error) << "Failed to translate the parameters of CDB API passed to the procedure." << endl
                          << "The current application may be misconfigured." << endmsg;
            return CdbStatus::Error;
        }
    }

  // Make adjustments to the database if 0 pointer was passed

    std::string databaseName;
    if( CdbStatus::Success != implementationPtr->getDefaultDatabase( databaseName )) {

        ErrMsg(fatal) << "Failed to obtain the default database from the following implementation" << endl
                      << "    TECHNOLOGY     : \"" << technologyName << "\"" << endl
                      << "    IMPLEMENTATION : \"" << implementationName << "\"" << endl
                      << "The problem can be caused either by a misconfigured application or" << endl
                      << "by a bug in the corresponding CDB API implementation module." << endmsg;
    }

    if( 0 != theDatabaseName ) databaseName = theDatabaseName;
    if( "" == databaseName ) return CdbStatus::IllegalParameters;

  // Finish

    return implementationPtr->getDefaultView( theViewName,
                                              databaseName.c_str( ));
}

CdbStatus
CdbEnvironmentImpl::getDefaultPath( std::string& theViewName,
                                    std::string& theDatabaseName,
                                    std::string& theImplementationName,
                                    std::string& theTechnologyName )
{
  // Make sure the underlying implementations of CDB API registered
  // in the dictionary are properly initialized.

    initialize( );

  // Get the components of the pass one-by-one

    std::string technologyName;
    {
        CdbStatus status = getDefaultTechnology( technologyName );
        if     ( CdbStatus::Success  == status ) ;
        else if( CdbStatus::NotFound == status ) return status;
        else {
            ErrMsg(error) << "Failed to obtain the default 'technology' of CDB API." << endl
                          << "The current application may be misconfigured." << endmsg;
            return CdbStatus::Error;
        }
    }

    std::string implementationName;
    {
        CdbStatus status = getDefaultImplementation( implementationName,
                                                     technologyName.c_str( ));
        if     ( CdbStatus::Success  == status ) ;
        else if( CdbStatus::NotFound == status ) return status;
        else {
            ErrMsg(error) << "Failed to obtain the default 'implementation' of CDB API." << endl
                          << "The current application may be misconfigured." << endmsg;
            return CdbStatus::Error;
        }
    }

    std::string databaseName;
    {
        CdbStatus status = getDefaultDatabase( databaseName,
                                               implementationName.c_str( ),
                                               technologyName.c_str( ) );
        if     ( CdbStatus::Success  == status ) ;
        else if( CdbStatus::NotFound == status ) return status;
        else {
            ErrMsg(error) << "Failed to obtain the default 'database' of CDB API." << endl
                          << "The current application may be misconfigured." << endmsg;
            return CdbStatus::Error;
        }
    }
    std::string viewName;
    {
        CdbStatus status = getDefaultView( viewName,
                                           databaseName.c_str( ),
                                           implementationName.c_str( ),
                                           technologyName.c_str( ) );
        if     ( CdbStatus::Success  == status ) ;
        else if( CdbStatus::NotFound == status ) return status;
        else {
            ErrMsg(error) << "Failed to obtain the default 'view' of CDB API." << endl
                          << "The current application may be misconfigured." << endmsg;
            return CdbStatus::Error;
        }
    }

  // Done

    theTechnologyName     = technologyName;
    theImplementationName = implementationName;
    theDatabaseName       = databaseName;
    theViewName           = viewName;

    return CdbStatus::Success;
}

CdbStatus
CdbEnvironmentImpl::setDefaultTechnology( const char* theTechnologyName )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbEnvironmentImpl::setDefaultImplementation( const char* theImplementationName,
                                              const char* theTechnologyName )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbEnvironmentImpl::setDefaultDatabase( const char* theDatabaseName,
                                        const char* theImplementationName,
                                        const char* theTechnologyName )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbEnvironmentImpl::setDefaultView( const char* theViewName,
                                    const char* theDatabaseName,
                                    const char* theImplementationName,
                                    const char* theTechnologyName )
{
    return CdbStatus::NotImplemented;
}

CdbStatus
CdbEnvironmentImpl::setDefaultPath( const char* theViewName,
                                    const char* theDatabaseName,
                                    const char* theImplementationName,
                                    const char* theTechnologyName )
{
  // Make sure the underlying implementations of CDB API registered
  // in the dictionary are properly initialized.

    initialize( );

  // DESIGN NOTE: The algorithm below assumes that specified 'technology' and
  //              'implementation' are already registered in the dictionary
  //              and that the corresponding object implementing CDB API
  //              will respect both of specified database and view names.

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify parameters

        if(( 0 == theTechnologyName ) ||
           ( 0 == strcmp( "", theTechnologyName )) ||
           ( 0 == theImplementationName ) ||
           ( 0 == strcmp( "", theImplementationName ))) return CdbStatus::IllegalParameters;

      // Find the technology

        std::string technologyName = theTechnologyName;
        if( _technologies.find( technologyName ) == _technologies.end( )) {

            ErrMsg(error) << "Specified 'technology' is unknown." << endl
                          << "    TECHNOLOGY : \"" << technologyName << "\"" << endmsg;
            break;
        }

      // Find the implementation

        CdbPtr implementationPtr;

        std::string implementationName = theImplementationName;
        if( !_technologies[technologyName].find( implementationPtr,
                                                 implementationName )) {

            ErrMsg(error) << "Specified 'implementation' is unknown." << endl
                          << "    TECHNOLOGY     : \"" << technologyName << "\"" << endl
                          << "    IMPLEMENTATION : \"" << implementationName << "\"" << endmsg;
            break;
        }

      // Propagate request down to the found implementation to set up default
      // database and the view.

        if( CdbStatus::Success != implementationPtr->setDefaultDatabase( theDatabaseName )) {

            ErrMsg(error) << "Failed to set default database." << endl
                          << "    TECHNOLOGY     : \"" << technologyName << "\"" << endl
                          << "    IMPLEMENTATION : \"" << implementationName << "\"" << endl
                          << "    DATABASE       : \"" << theDatabaseName << "\"" << endmsg;
            break;
        }
        if( CdbStatus::Success != implementationPtr->setDefaultView( theViewName, theDatabaseName )) {

            ErrMsg(error) << "Failed to set default view." << endl
                 << "    TECHNOLOGY     : \"" << technologyName << "\"" << endl
                 << "    IMPLEMENTATION : \"" << implementationName << "\"" << endl
                 << "    DATABASE       : \"" << theDatabaseName << "\"" << endl
                 << "    VIEW           : \"" << theViewName << "\"" << endmsg;
            break;
        }

      // Remember new defaults

        if( !_technologies[technologyName].setDefault( implementationName )) {

            ErrMsg(error) << "Failed to set specified 'implementation' as the default one." << endl
                 << "    TECHNOLOGY     : \"" << technologyName << "\"" << endl
                 << "    IMPLEMENTATION : \"" << implementationName << "\"" << endmsg;
            break;
        }
        _defaultTechnologyName = technologyName;

      // Done

        CDB_DEBUG_STREAM << "Condition/DB API defaults set to "
                         << " TECHNOLOGY=\"" << theTechnologyName << "\""
                         << " IMPLEMENTATION=\"" << theImplementationName << "\""
                         << " DATABASE=\"" << theDatabaseName << "\""
                         << " VIEW=\"" << theViewName << "\"" << endl;
 
        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbEnvironmentImpl::set( CdbPtr& thePtr )
{
  // IMPORTANT NOTE: This method does NOT initialize implementations to avoid any actual
  //                 interructions with persistent store(s) before they are going to be used.

//    initialize( );

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify parameters

        if( thePtr.isNull( )) {
            result = CdbStatus::IllegalParameters;
            break;
        }
        std::string technologyName     = thePtr->technologyName( );
        std::string implementationName = thePtr->implementationName( );

      // Find the technology first. Create it if it does not exist.
      //
      // NOTE: If thsi is going to be the very first technology then it will automatically
      //       become the default one.

        if( 0 == _technologies.size( )) {

            _technologies[technologyName] = Technology( );
            _defaultTechnologyName        = technologyName;

        } else {

            std::map<std::string, Technology>::iterator technologyItr = _technologies.find( technologyName );
            if( technologyItr == _technologies.end( )) _technologies[technologyName] = Technology( );
        }

      // Insert the implementation into found technology the implementation.
      //
      // NOTE: There should not be any other implementation under the same name.
      //       Report a problem back to the caller if there is one.

        if( !(_technologies[technologyName].insert( thePtr ))) {

            ErrMsg(error) << "The CDB API implementation with specified parameters has already been registered." << endl
                          << "    TECHNOLOGY     : \"" << technologyName << "\"" << endl
                          << "    IMPLEMENTATION : \"" << implementationName << "\"" << endmsg;

            break;
        }

      // Done

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbEnvironmentImpl::get( CdbPtr&     thePtr,
                         const char* theTechnologyName,
                         const char* theImplementationName )
{
  // Make sure the underlying implementations of CDB API registered
  // in the dictionary are properly initialized.

    initialize( );

    CdbStatus result = CdbStatus::Error;
    do {

      // Verify parameters

        if(( 0 == theTechnologyName ) ||
           ( 0 == strcmp( "", theTechnologyName )) ||
           ( 0 == theImplementationName ) ||
           ( 0 == strcmp( "", theImplementationName ))) {

            result = CdbStatus::IllegalParameters;
            break;
        }

      // Find the technology first

        std::map<std::string, Technology>::iterator technologyItr = _technologies.find( std::string( theTechnologyName ));
        if( technologyItr == _technologies.end( )) {
            result = CdbStatus::NotFound;
            break;
        }

      // Find the implementation

        CdbPtr implementationPtr;
        if( !technologyItr->second.find( implementationPtr,
                                         std::string( theImplementationName ))) {
            result = CdbStatus::NotFound;
            break;
        }

      // Done

        thePtr = implementationPtr;

        result = CdbStatus::Success;

    } while(false);

    return result;
}

CdbAnyTypeDict<std::string>&
CdbEnvironmentImpl::extra( )
{
    return _extra;
}

void
CdbEnvironmentImpl::initialize( )
{
  // Walk through each CDB API implementation and check for those which are
  // not initialized yet.

    for( std::map<std::string, Technology>::iterator technologyItr = _technologies.begin( );
         technologyItr != _technologies.end( );
         ++technologyItr ) {

        for( std::map<std::string, CdbPtr>::iterator implementationItr = technologyItr->second._implementations.begin( );
             implementationItr != technologyItr->second._implementations.end( );
             ++implementationItr ) {

            CdbPtr ptr = (*implementationItr).second;

            if( !ptr->isInitialized( )) ptr->initialize( );
        }
    }
}

CdbStatus
CdbEnvironmentImpl::translateAndVerify( std::string& theOutTechnologyName,
                                        const char*  theInTechnologyName )
{
  // Make adjustment to the technology if 0 pointer was passed.

    std::string technologyName;
    if( CdbStatus::Success != getDefaultTechnology( technologyName )) {

        ErrMsg(error) << "Failed to obtain the default CDB API 'technology'." << endl
                      << "The current application may be misconfigured." << endmsg;
        return CdbStatus::Error;
    }

    if( 0 != theInTechnologyName ) technologyName = theInTechnologyName;
    if( "" == technologyName ) return CdbStatus::IllegalParameters;

  // Find the technology
  //
  // NOTE: If this operation will fail then depending on which source of information
  //       we used we produce different return status. If the default value was used
  //       we have internally inconsistent data structure.

    std::map<std::string, Technology>::iterator technologyItr = _technologies.find( technologyName );
    if( technologyItr == _technologies.end( )) return CdbStatus::NotFound;

  // Done

    theOutTechnologyName  = technologyName;

    return CdbStatus::Success;
}

CdbStatus
CdbEnvironmentImpl::translateAndVerify( std::string& theOutTechnologyName,
                                        std::string& theOutImplementationName,
                                        CdbPtr&      thePtr,
                                        const char*  theInTechnologyName,
                                        const char*  theInImplementationName )
{
  // Make adjustment to the technology.

    std::string technologyName;
    {
        CdbStatus result = translateAndVerify( technologyName, theInTechnologyName );
        if( CdbStatus::Success != result ) return result;
    }

  // Make adjustment to the implementation if 0 pointer was passed.

    std::string implementationName;
    if( CdbStatus::Success != getDefaultImplementation( implementationName,
                                                        technologyName.c_str( ))) {

        ErrMsg(error) << "Failed to obtain the default CDB API 'implementation'." << endl
                      << "The current application may be misconfigured." << endmsg;
        return CdbStatus::Error;
    }

    if( 0 != theInImplementationName ) implementationName = theInImplementationName;
    if( "" == technologyName ) return CdbStatus::IllegalParameters;

  // Find the implementation
  //
  // NOTE: If this operation will fail then depending on which source of information
  //       we used we produce different return status. If the default value was used
  //       we have internally inconsistent data structure.

    CdbPtr implementationPtr;
    if( !(_technologies[technologyName].find( implementationPtr,
                                              implementationName.c_str( )))) return CdbStatus::NotFound;

  // Done

    theOutTechnologyName     = technologyName;
    theOutImplementationName = implementationName;
    thePtr                   = implementationPtr;

    return CdbStatus::Success;
}

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

---