---

CdbSQLApiFolder.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbSQLApiFolder.cc,v 1.1 2005/09/06 18:01:10 gapon Exp $

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

#include "BaBar/BaBar.hh"

#include "CdbSQL/CdbSQLApiFolder.hh"
#include "CdbSQL/CdbSQLApiCondition.hh"
#include "CdbSQL/CdbSQL.hh"
#include "CdbSQL/CdbSQLOrigin.hh"
#include "CdbSQL/CdbSQLFolder.hh"
#include "CdbSQL/CdbSQLConditionAtFolder.hh"
#include "CdbSQL/CdbSQLCondition.hh"

#include "CdbBase/CdbPathName.hh"
#include "CdbBase/CdbDatabase.hh"
#include "CdbBase/CdbView.hh"
#include "CdbBase/CdbVectorAdapterItr.hh"

#include <assert.h>

#include <iostream>
using std::cout;
using std::endl;

namespace {

  /////////////////////////////////
  // Class: IteratorOfSubFolders //
  /////////////////////////////////

    class IteratorOfSubFolders : public CdbVectorAdapterItr<const char*, CdbCPtr<CdbSQLFolder> > {

    private:

      /// The default constructor (NOT IMPLEMENTED)

        IteratorOfSubFolders( );

      /// The assignment operator (NOT IMPLEMENTED)

        IteratorOfSubFolders& operator=( const IteratorOfSubFolders& );

    protected:

      /// The copy constructor

        IteratorOfSubFolders( const IteratorOfSubFolders& theItr ) :
            CdbVectorAdapterItr<const char*, CdbCPtr<CdbSQLFolder> >( theItr )
        { }

    public:

      /// The normal constructor
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        IteratorOfSubFolders( const std::vector< CdbCPtr<CdbSQLFolder> >& theList ) :
            CdbVectorAdapterItr<const char*, CdbCPtr<CdbSQLFolder> >( theList )
        { }

      /// Make a clone of itself
      /**
        * @see CdbIItr::clone()
        */
        virtual CdbIItr<const char*>* clone( ) const
        {
            return new IteratorOfSubFolders( *this );
        }

    protected:

      /// User defined translation for the currently reffered value
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        virtual const char* toValue( const CdbCPtr<CdbSQLFolder>& thePtr ) const
        {
            return thePtr->name( ).c_str( );
        }
    };

  ////////////////////////////////
  // Class IteratorOfConditions //
  ////////////////////////////////

    class IteratorOfConditions : public CdbVectorAdapterItr<const char*, CdbCPtr<CdbSQLConditionAtFolder> > {

    private:

      /// The default constructor (NOT IMPLEMENTED)

        IteratorOfConditions( );

      /// The assignment operator (NOT IMPLEMENTED)

        IteratorOfConditions& operator=( const IteratorOfConditions& );

    protected:

      /// The copy constructor

        IteratorOfConditions( const IteratorOfConditions& theItr ) :
            CdbVectorAdapterItr<const char*, CdbCPtr<CdbSQLConditionAtFolder> >( theItr )
        { }

    public:

      /// The normal constructor
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        IteratorOfConditions( const std::vector< CdbCPtr<CdbSQLConditionAtFolder> >& theList ) :
            CdbVectorAdapterItr<const char*, CdbCPtr<CdbSQLConditionAtFolder> >( theList )
        { }

      /// Make a clone of itself
      /**
        * @see CdbIItr::clone()
        */
        virtual CdbIItr<const char*>* clone( ) const
        {
            return new IteratorOfConditions( *this );
        }

    protected:

      /// User defined translation for the currently reffered value
      /**
        * @see CdbVectorAdapterItr::CdbVectorAdapterItr()
        */
        virtual const char* toValue( const CdbCPtr<CdbSQLConditionAtFolder>& thePtr ) const
        {
            return thePtr->name( ).c_str( );
        }
    };
}

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

CdbSQLApiFolder::CdbSQLApiFolder( const CdbViewPtr&            theParentViewPtr,
                                  const CdbFolderPtr&          theParentFolderPtr,
                                  const char*                  theName,
                                  const CdbCPtr<CdbSQLFolder>& theFolderPtr,
                                  const CdbCPtr<CdbSQLOrigin>& theMasterOriginPtr,
                                  const CdbCPtr<CdbSQLOrigin>& theLocalOriginPtr ) :
    CdbFolder( theParentViewPtr,
               theParentFolderPtr,
               theName ),
    _myFolderPtr         (theFolderPtr),
    _myMasterSQLOriginPtr(theMasterOriginPtr),
    _myLocalSQLOriginPtr (theLocalOriginPtr)
{
    assert( !theFolderPtr.isNull( ));
    assert( !theMasterOriginPtr.isNull( ));
    assert( !theLocalOriginPtr.isNull( ));
}

CdbSQLApiFolder::~CdbSQLApiFolder( )
{ }

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

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

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

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

BdbTime
CdbSQLApiFolder::created( ) const
{
    return _myFolderPtr->created( );
}

std::string
CdbSQLApiFolder::description( ) const
{
    return _myFolderPtr->description( );
}

CdbStatus
CdbSQLApiFolder::findFolder( CdbFolderPtr& thePtr,
                             const char*   theName )
{
    const char* errorStr = "CdbSQLApiFolder::findFolder() -- ERROR";

    CdbStatus status = CdbStatus::Error;

  // Verify parameters

    if( 0 == theName ) {
        cout << errorStr << endl
             << "    Non 0 pointer onto a folder name was expected." << endl;

        return CdbStatus::IllegalParameters;
    }

    CdbPathName fPath( theName );

    if( ! ( fPath.isValid( ) &&
            ! fPath.isRoot( ) &&
            ! fPath.isAbsolute( ) &&
            ! fPath.isComposite( ))) {

        cout << errorStr << endl
             << "    Unsupported format of the folder name. Simple non-root folder" << endl
             << "    name was expected." << endl
             << "        CURRENT FOLDER : \"" << name( ) << "\"" << endl
             << "        SUB-FOLDER     : \"" << theName << "\"" << endl;
        return CdbStatus::IllegalParameters;
    }

   // Find out persistent folder for specified name

    CdbCPtr<CdbSQLFolder> folderPtr;
    if( CdbStatus::Success != ( status = _myFolderPtr->find_folder( folderPtr,
                                                                    std::string( theName )))) {
        cout << errorStr << endl
             << "    Failed to find a subfolder in a scope of the current folder." << endl
             << "        CURRENT FOLDER : \"" << name( ) << "\"" << endl
             << "        SUB-FOLDER     : \"" << theName << "\"" << endl;
        return status;
    }

  // Construct transient CDB API object

    thePtr = new CdbSQLApiFolder( parentView( ),
                                  CdbFolderPtr( this->clone( )),
                                  theName,
                                  folderPtr,
                                  _myMasterSQLOriginPtr,
                                  _myLocalSQLOriginPtr );
    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiFolder::folderIterator( CdbFolderItr& theItr )
{
    const char* errorStr = "CdbSQLApiFolder::folderIterator() -- ERROR.";

    CdbStatus status = CdbStatus::Error;

  // Find all folders in the scope of the current pesistent folder

    std::vector< CdbCPtr<CdbSQLFolder> > folders;
    if( CdbStatus::Success != ( status = _myFolderPtr->folders( folders ))) {
        cout << errorStr << endl
             << "    Failed to obtain a list of sub-folders at the current folder." << endl
             << "        FOLDER NAME : \"" << name( ) << "\"." << endl;
        return status;
    }
    theItr = CdbFolderItr( new IteratorOfSubFolders( folders ));

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiFolder::findCondition( CdbConditionPtr& thePtr,
                                const char*      theName )
{
    const char* errorStr = "CdbSQLApiFolder::findCondition() -- ERROR";

    CdbStatus status = CdbStatus::Error;

  // Verify parameters

    if( 0 == theName ) {
        cout << errorStr << endl
             << "    Non 0 pointer onto a condition name was expected." << endl;
        return CdbStatus::IllegalParameters;
    }

    CdbPathName cPath( theName );

    if( ! ( cPath.isValid( ) &&
            ! cPath.isRoot( ) &&
            ! cPath.isAbsolute( ) &&
            ! cPath.isComposite( ))) {

        cout << errorStr << endl
             << "    Unsupported format of the condition name. Simple non-root" << endl
             << "    name was expected." << endl
             << "        CURRENT FOLDER : \"" << name( ) << "\"" << endl
             << "        CONDITION      : \"" << theName << "\"" << endl;
        return CdbStatus::IllegalParameters;
    }

   // Find out persistent condition (at folder) for specified name

    CdbCPtr<CdbSQLConditionAtFolder> conditionAtFolderPtr;
    if( CdbStatus::Success != ( status = _myFolderPtr->find_condition( conditionAtFolderPtr,
                                                                       std::string( theName )))) {
        cout << errorStr << endl
             << "    Failed to find the specified condition at the current folder." << endl
             << "        CURRENT FOLDER : \"" << name( ) << "\"" << endl
             << "        CONDITION      : \"" << theName << "\"" << endl;
        return status;
    }

  // Find out the "physical" condition corresponding to the found one

    CdbCPtr<CdbSQLCondition> conditionPtr;
    {
        CdbId conditionId = conditionAtFolderPtr->physicalId( );

      // Find a persistent origin where the specified physical condition is supposed to belong to.

        CdbCPtr<CdbSQLOrigin> originPtr;
        if( CdbStatus::Success != ( status = findOriginObject( originPtr,
                                                               conditionId.origin ))) {
            cout << errorStr << endl
                 << "    An owner origin for the 'physical' condition was not found." << endl
                 << "        'PHYSICAL' CONDITION ID : \"" << conditionId << "\"." << endl;
            return status;
        }
        if( CdbStatus::Success != ( status = originPtr->find_condition( conditionPtr,
                                                                        conditionId.local ))) {
            cout << errorStr << endl
                 << "    Failed to find the condition object for identifier: " << conditionId.local << endl
                 << "    in a scope of the origin with identifier: " << conditionId.origin << endl
                 << "    The database may not be properly initialized/loaded." << endl;
            return status;
        }
    }

  // Construct transient CDB API object

    thePtr = new CdbSQLApiCondition( CdbFolderPtr( this->clone( )),
                                     parentView( )->parent( ),
                                     theName,
                                     conditionAtFolderPtr,
                                     conditionPtr,
                                     _myMasterSQLOriginPtr,
                                     _myLocalSQLOriginPtr );
    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiFolder::conditionIterator( CdbConditionItr& theItr )
{
    const char* errorStr = "CdbSQLApiFolder::conditionIterator() -- ERROR.";

    CdbStatus status = CdbStatus::Error;

  // Find all conditions in the scope of the current pesistent folder

    std::vector< CdbCPtr<CdbSQLConditionAtFolder> > conditions;
    if( CdbStatus::Success != ( status = _myFolderPtr->conditions( conditions ))) {
        cout << errorStr << endl
             << "    Failed to obtain a list of conditions at the current folder." << endl
             << "        CURRENT FOLDER : \"" << name( ) << "\"." << endl;
        return status;
    }
    theItr = CdbConditionItr( new IteratorOfConditions( conditions ));

    return CdbStatus::Success;
}

CdbStatus
CdbSQLApiFolder::findOriginObject( CdbCPtr<CdbSQLOrigin>& thePtr,
                                   unsigned short         theId )
{
    const char* errorStr = "CdbSQLApiFolder::findOriginObject() -- ERROR.";

  // A little optimization to use already found and cached MASTER and local
  // origin objects in case if one of them gets requested.
 
    CdbCPtr<CdbSQLOrigin> originPtr;

    if(      theId == _myMasterSQLOriginPtr->id( )) originPtr = _myMasterSQLOriginPtr;
    else if( theId == _myLocalSQLOriginPtr->id( ))  originPtr = _myLocalSQLOriginPtr;
    else {

        CdbStatus status = _myMasterSQLOriginPtr->parent( )->find_origin( originPtr,
                                                                          theId );
        if( CdbStatus::Success != status ) {
            cout << errorStr << endl
                 << "    Failed to find the origin by its identifier." << endl
                 << "        ORIGIN ID : " << theId << endl;
            return status;
        }
    }
    thePtr = originPtr;

    return CdbStatus::Success;
}

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

---