---

CdbEnvironment.cc

Go to the documentation of this file.

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

/// The implementation of the CdbEnvironment singleton.
/**
  * @see CdbEnvironment
  */

#include "BaBar/BaBar.hh"

#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/CdbEnvironmentImpl.hh"
#include "CdbBase/CdbStateId.hh"
#include "CdbBase/CdbView.hh"

#include "ErrLogger/ErrLog.hh"

#include <assert.h>

namespace {

    int& debugMode( )
    {
        static int mode = 0;
        return mode;
    }
};

int
CdbEnvironment::setDebugMode( int newMode )
{
    int oldMode = debugMode( );
    {
        debugMode( ) = newMode;
    }
    return oldMode;
}

int
CdbEnvironment::getDebugMode( )
{
    return debugMode( );
}

CdbStateId
CdbEnvironment::defaultStateId( const BdbTime& theValidityTime )
{
  // Obtain the value of this identifier through the default database.

    CdbViewPtr vPtr;

    if( CdbStatus::Success != CdbView::instance( vPtr )) {
        ErrMsg(error) << "Failed to locate the default view. Generating invalid state identifier." << endmsg;
        return CdbStateId( );
    }
    return vPtr->currentStateId( theValidityTime );
}

BdbTime
CdbEnvironment::getTruncateTime( )
{
    return impl( )->getTruncateTime( );
}

BdbTime
CdbEnvironment::setTruncateTime( const BdbTime& theNewTruncateTime )
{
    return impl( )->setTruncateTime( theNewTruncateTime );
}

std::string
CdbEnvironment::defaultTechnology( )
{
    std::string technology;
    CdbStatus result = impl( )->getDefaultTechnology( technology );

    assert( CdbStatus::Success == result ); // an apparent bug in the implementation class

    return technology;
}

std::string
CdbEnvironment::defaultImplementation( const char* theTechnologyName )
{
    std::string implementation;
    CdbStatus result = impl( )->getDefaultImplementation( implementation,
                                                          theTechnologyName );

    assert( CdbStatus::Success == result ); // an apparent bug in the implementation class

    return implementation;
}

std::string
CdbEnvironment::defaultDatabase( const char* theTechnologyName,
                                 const char* theImplementationName )
{
    std::string database;
    CdbStatus result = impl( )->getDefaultDatabase( database,
                                                    theImplementationName,
                                                    theTechnologyName );

    assert( CdbStatus::Success == result ); // an apparent bug in the implementation class

    return database;
}

std::string
CdbEnvironment::defaultView( const char* theTechnologyName,
                             const char* theImplementationName,
                             const char* theDatabaseName )
{
    std::string view;
    CdbStatus result = impl( )->getDefaultView( view,
                                                theDatabaseName,
                                                theImplementationName,
                                                theTechnologyName );

    assert( CdbStatus::Success == result ); // an apparent bug in the implementation class

    return view;
}

void
CdbEnvironment::setDefault( const char* theTechnologyName,
                            const char* theImplementationName,
                            const char* theDatabaseName,
                            const char* theViewName )
{
    CdbStatus result = impl( )->setDefaultPath( theViewName,
                                                theDatabaseName,
                                                theImplementationName,
                                                theTechnologyName );

    assert( CdbStatus::Success == result ); // an apparent bug in the implementation class
}

CdbStatus
CdbEnvironment::getDefaultTechnology( std::string& theTechnologyName )
{
    return impl( )->getDefaultTechnology( theTechnologyName );
}

CdbStatus
CdbEnvironment::getDefaultImplementation( std::string& theImplementationName,
                                          const char*  theTechnologyName )
{
    return impl( )->getDefaultImplementation( theImplementationName,
                                              theTechnologyName );
}

CdbStatus
CdbEnvironment::getDefaultDatabase( std::string& theDatabaseName,
                                    const char*  theImplementationName,
                                    const char*  theTechnologyName )
{
    return impl( )->getDefaultDatabase( theDatabaseName,
                                        theImplementationName,
                                        theTechnologyName );
}

CdbStatus
CdbEnvironment::getDefaultView( std::string& theViewName,
                                const char*  theDatabaseName,
                                const char*  theImplementationName,
                                const char*  theTechnologyName )
{
    return impl( )->getDefaultView( theViewName,
                                    theDatabaseName,
                                    theImplementationName,
                                    theTechnologyName );
}

CdbStatus
CdbEnvironment::getDefaultPath( std::string& theViewName,
                                std::string& theDatabaseName,
                                std::string& theImplementationName,
                                std::string& theTechnologyName )
{
    return impl( )->getDefaultPath( theViewName,
                                    theDatabaseName,
                                    theImplementationName,
                                    theTechnologyName );
}

CdbStatus
CdbEnvironment::setDefaultTechnology( const char* theTechnologyName )
{
    return impl( )->setDefaultTechnology( theTechnologyName );
}

CdbStatus
CdbEnvironment::setDefaultImplementation( const char* theImplementationName,
                                          const char* theTechnologyName )
{
    return impl( )->setDefaultImplementation( theImplementationName,
                                              theTechnologyName );
}

CdbStatus
CdbEnvironment::setDefaultDatabase( const char* theDatabaseName,
                                    const char* theImplementationName,
                                    const char* theTechnologyName )
{
    return impl( )->setDefaultDatabase( theDatabaseName,
                                        theImplementationName,
                                        theTechnologyName );
}

CdbStatus
CdbEnvironment::setDefaultView( const char* theViewName,
                                const char* theDatabaseName,
                                const char* theImplementationName,
                                const char* theTechnologyName )
{
    return impl( )->setDefaultView( theViewName,
                                    theDatabaseName,
                                    theImplementationName,
                                    theTechnologyName );
}

CdbStatus
CdbEnvironment::setDefaultPath( const char* theViewName,
                                const char* theDatabaseName,
                                const char* theImplementationName,
                                const char* theTechnologyName )
{
    return impl( )->setDefaultPath( theViewName,
                                    theDatabaseName,
                                    theImplementationName,
                                    theTechnologyName );
}


CdbAnyTypeDict<std::string>&
CdbEnvironment::extra( )
{
    return impl( )->extra( );
}

CdbStatus
CdbEnvironment::set( CdbPtr& thePtr )
{
    return impl( )->set( thePtr );
}

CdbStatus
CdbEnvironment::get( CdbPtr&     thePtr,
                     const char* theTechnologyName,
                     const char* theImplementationName  )
{
    return impl( )->get( thePtr,
                         theTechnologyName,
                         theImplementationName );
}

CdbEnvironmentImpl*
CdbEnvironment::impl( )
{
    static CdbEnvironmentImpl currentImpl;
    return &currentImpl;
}

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

---