---

CdbBdbWFolder.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbWFolder.cc,v 1.14 2004/12/08 09:15:13 gapon Exp $

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

#include "BaBar/BaBar.hh"

#include "CdbBdbWrapper/CdbBdbWFolder.hh"

#include "CdbBase/Cdb.hh"
#include "CdbBase/CdbPathName.hh"
#include "CdbBase/CdbDatabase.hh"

#include "CdbBdbWrapper/CdbBdbWListOfDetectors.hh"
#include "CdbBdbWrapper/CdbBdbWFolderItr.hh"
#include "CdbBdbWrapper/CdbBdbWCondition.hh"
#include "CdbBdbWrapper/CdbBdbWConditionItr.hh"

#include "BdbCond/BdbCondDatabaseMgr.hh"

#include "ErrLogger/ErrLog.hh"

CdbFolder*
CdbBdbWFolder::clone( ) const
{
    CdbBdbWFolder* mySelf = const_cast<CdbBdbWFolder*>( this );
    return new CdbBdbWFolder( mySelf->parentView( ),
                              mySelf->parentFolder( ),
                              mySelf->name( ));
}

CdbBdbWFolder::CdbBdbWFolder( const CdbViewPtr&   theViewPtr,
                              const CdbFolderPtr& theFolderPtr,
                              const char*         theName ) :
    CdbFolder( theViewPtr,
               theFolderPtr,
               theName )
{ }

CdbBdbWFolder::~CdbBdbWFolder( )
{ }

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

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

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

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

BdbTime
CdbBdbWFolder::created( ) const
{
    return BdbTime::minusInfinity;
}

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

CdbStatus
CdbBdbWFolder::findFolder( CdbFolderPtr& thePtr,
                           const char*   theName
                         )
{
    CdbStatus result = CdbStatus::Error;

    thePtr = 0;

    do {

        if( !parentFolder( ).isNull( )) {
            ErrMsg(error) << "this implementation does not support folders of specified depth." << endmsg;
            break;
        }
/**
 ** IMPLEMENTATION NOTE: The following check has been disabled to provide
 **                      beckward behavioral compatibility with the old
 **                      Condition/DB, which allows non-existing container creation
 **                      on a very first request to BdbDatabase::store methods.
 **                      The BdbDatabase::find/fetch methods will fail anyway.
 **
 **     CdbBdbWListOfDetectors listOfDetectors;
 **     size_t                 elements = listOfDetectors.elements( );
 **
 **     for( size_t i = 0; i < elements; i++ ) {
 **
 **         if( 0 == strcmp( theName, listOfDetectors[i] )) {
 **/
              // 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.

                CdbFolderPtr myPtr( this->clone( ));

                thePtr = new CdbBdbWFolder( parentView( ),
                                            myPtr,
                                            theName );

                result = CdbStatus::Success;
/**
 **             break;
 **         }
 **     }
 **/
        if( CdbStatus::Success != result ) {
            ErrMsg(error) << "specified folder was not found in the database." << endmsg;
            break;
        }

    } while( false );

    return result;
}

CdbStatus
CdbBdbWFolder::folderIterator( CdbFolderItr& theItr )
{
    CdbFolderPtr myPtr( this->clone( ));

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

    theItr = CdbFolderItr( new CdbBdbWFolderItr( myPtr ));

    return CdbStatus::Success;
}

CdbStatus
CdbBdbWFolder::findCondition( CdbConditionPtr& thePtr,
                              const char*      theName
                            )
{
    CdbStatus result = CdbStatus::Error;

    thePtr = 0;

    do {

      // Evaluate if the current folder is allowed to have conditions, that is
      // it (folder) has the following name:
      //
      //    "/<detector>/<condition>"
      //
      // and that specified condition has simple non-composite name:
      //
      //    "<condition>"

        if( ! ( !parentFolder( ).isNull( ) &&
                !parentFolder( )->parentView( ).isNull( ))) {

            ErrMsg(error) << "this implementation only allows conditions at in detector/subsystem folders." << endmsg;
            break;
        }

        CdbPathName detectorName( name( ));
        CdbPathName conditionName( theName );

        if( ! ( detectorName.isValid( )       &&
                conditionName.isValid( )      &&
                ! conditionName.isAbsolute( ) &&
                ! conditionName.isComposite( ))) {

            ErrMsg(error) << "invalid condition name passed. Simple non-composite name was expected." << endmsg;
            break;
        }
/**
 ** IMPLEMENTATION NOTE: The following check has been disabled to provide
 **                      beckward behavioral compatibility with the old
 **                      Condition/DB, which allows non-existing container creation
 **                      on a very first request to BdbDatabase::store methods.
 **                      The BdbDatabase::find/fetch methods will fail anyway.
 ** 
 **
 **   // Check the presence of the condition itself
 **   //
 **   // WARNING: This operation can possibly be replaced with further request
 **   //          to the DETECTOR/SUBSYSTEM level folder.
 **
 **     bool existsFlag = false;
 **
 **     BdbCondDatabaseMgr condDbMg;
 **     if( BdbcSuccess != condDbMg.evaluateIntervalContainer( detectorName,
 **                                                            conditionName,
 **                                                            existsFlag )) {
 **
 **         ErrMsg(error) << "failed to evaluate the presence of specified condition." << endmsg;
 **         break;
 **     }
 **     if( ! existsFlag ) {
 **         ErrMsg(error) << "specified condition does not exist in the database." << 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 resulting condition object gets as its parameter the condition name
      //       only rather than its full path.

      // NOTE: The owner database API object is not set.

        CdbFolderPtr myPtr( this->clone( ));

        CdbDatabasePtr databasePtr = 0;

        thePtr = new CdbBdbWCondition( myPtr,
                                       databasePtr,
                                       conditionName.toString( ).c_str( ));

        result = CdbStatus::Success;

    } while( false );

    return result;
}

CdbStatus
CdbBdbWFolder::conditionIterator( CdbConditionItr& theItr )
{
    CdbFolderPtr myPtr( this->clone( ));

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

    theItr = CdbConditionItr( new CdbBdbWConditionItr( myPtr ));

    return CdbStatus::Success;
}

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

---