---

CdbBdbPrintObjectTreeImpl.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbPrintObjectTreeImpl.cc,v 1.5 2004/10/21 20:35:51 gapon Exp $
#include "BaBar/BaBar.hh"

/// The implementation of the CdbBdbPrintObjectTreeImpl.
/**
  * @see CdbBdbPrintObjectTreeImpl
  */

#include "BaBar/BaBar.hh"

#include "CdbBdb/CdbBdbPrintObjectTreeImpl.hh"

#include "CdbBdb/CdbBdbPrintObjectTreeUserAction.hh"
#include "CdbBdb/CdbBdbSimpleCache.hh"

#include <assert.h>

#include <iostream>     // Use STD I/O streams to avoid conflicts with
                        // Objectivity/DB Active Schema API caused by a bug
                        // in its header file at version 7.

#include <ooMap.h>      // Objectivity/DB core API for the Map Dictionary class
using std::cerr;
using std::cout;
using std::endl;


//////////////////////////////////////
// CdbBdbPrintObjectTreeImpl::Prefix //
//////////////////////////////////////

CdbBdbPrintObjectTreeImpl::Prefix::Prefix(               int& theLevel,
                                           const std::string& theStep ) :
    _level(theLevel),
    _str  ("")
{
    ++_level;
    for( int i = 0; i < _level; ++i ) _str += theStep;
}

CdbBdbPrintObjectTreeImpl::Prefix::~Prefix( )
{
    --_level;
}
        
const char*
CdbBdbPrintObjectTreeImpl::Prefix::c_str( ) const
{
    return _str.c_str( );
}

///////////////////////
// CdbBdbPrintObjectTree //
///////////////////////

CdbBdbPrintObjectTreeImpl::CdbBdbPrintObjectTreeImpl( CdbBdbPrintObjectTreeUserAction* theUserAction,
                                                                                  bool verboseMode,
                                                                                  bool debugMode ) :
    _verboseMode(verboseMode),
    _debugMode  (debugMode),
    _userAction (theUserAction),
    _dictionary (new CdbBdbSimpleCache( )),
    _level      (0)
{
    if( 0 == theUserAction ) {
        cerr << "CdbBdbPrintObjectTreeImpl::CdbBdbPrintObjectTreeImpl() -- a null pointer instead of a valid user" << endl
             << "action object passed into the constructor." << endl;
        ::abort( );
    }

  // Force verbose mode if the debug mode is srequired

    if( _debugMode ) _verboseMode = true;
}

CdbBdbPrintObjectTreeImpl::~CdbBdbPrintObjectTreeImpl( )
{
    if( 0 != _dictionary ) {
        delete _dictionary;
        _dictionary = 0;
    }
}

bool
CdbBdbPrintObjectTreeImpl::print( const ooHandle(ooObj)& theInputH )
{
  // Accept only valid objects to begin with

    if( !theInputH.isValid( )) {
        cerr << "CdbBdbPrintObjectTreeImpl::print() -- an invalid object passed to the procedure: " << theInputH.sprint( ) << endl;
        return false;
    }

  // Reset the operation's context

    _level = 0;

  // Proceed with the copy

    return printObject( theInputH );
}

CdbBdbPrintObjectTreeUserAction*
CdbBdbPrintObjectTreeImpl::setUserAction( CdbBdbPrintObjectTreeUserAction* theUserAction )
{
    if( 0 == theUserAction ) { 
        cerr << "CdbBdbPrintObjectTreeImpl::setUserAction() -- a null pointer instead of a valid user" << endl 
             << "action object passed into the method." << endl;
        ::abort( );
    }

    CdbBdbPrintObjectTreeUserAction* previousAction = _userAction;
    _userAction = theUserAction;

    return previousAction;
}

bool
CdbBdbPrintObjectTreeImpl::printObject( const ooHandle(ooObj)& theInputH )
{
    const char* context = "CdbBdbPrintObjectTreeImpl::printObject() : ";

    Prefix prefix( _level );

////////////////////////////////////////////////////////////////
if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << " >> " << endl;
}
////////////////////////////////////////////////////////////////

  // Simply ignore the null objects. It's not a error conditions since its quite
  // normal for persistent objects to have null references.

    if( theInputH == 0 ) {

/////////////////////////////////////////////////////////////////////////////////////////////////////
//if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << endl;
//}
/////////////////////////////////////////////////////////////////////////////////////////////////////

    } else {

      // Find an object in the transient cache first if the cache is present
      // in the current test's environment.

        if( 0 != _dictionary->findObject( theInputH )) {

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << endl;
//}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        } else {

          // Engage a user action to see what has to be done next

            switch( _userAction->action( theInputH )) {

            default :
                {
                    bool isKnownUserAction = false;
                    assert( isKnownUserAction );
                }

            case CdbBdbPrintObjectTreeUserAction::ACTION_ERROR :

                cerr << context << "user action failed for: " << theInputH.sprint( ) << endl;
                return false;

            case CdbBdbPrintObjectTreeUserAction::ACTION_STOP :

                _dictionary->addObject( theInputH, theInputH );

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << " (STOP BY USER ACTION)" << endl;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                break;

            case CdbBdbPrintObjectTreeUserAction::ACTION_PROCEED :

                {
                  // Now we're diving into another object which has been successfully
                  // validated by the user action.


                  // Check for special case of the ooMap class. Use regular (as opposed to the Active
                  // Schema API) to browse the map.
                  //
                  // IMPLEMENTATION NOTE: In theory this operation could also be resolved for
                  //                      user defined subclasses of the ooMap class. Besides we have
                  //                      a set of other internal classes defined by Objectivity itself
                  //                      (containers, sets, B-Trees, etc.) It's unclear whether they
                  //                      can also be browsed in this way.

                    ooTypeNumber typeN = theInputH.typeN( );

                    if( ooTypeN(ooMap) == typeN ) {

                        ooHandle(ooMap) inputMapH;      // non-const handle is needed to set up an iterator
                        inputMapH = (ooHandle(ooMap))theInputH;

                      // ATTENTION: update the cache _before_ copying the object to prevent
                      //            "visit self" loop. This may cause crashes in the algorithm.

                        _dictionary->addObject( theInputH, theInputH );

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << endl;
//}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                        {
                            ooMapItr itr( inputMapH );
                            while( itr.next( )) {

                                ooRef(ooObj) inputRef = itr->oid( );

                                ooHandle(ooObj) inputH;
                                inputH = inputRef;

                                if( ! printObject( inputH )) return false;
                            }
                        }

                    } else {

                      // Visit the persisten object using recursive algorithm.
                      //
                      // NOTE: The cast is needed as a workaround of the buggy interface
                      //       of the "ooas::Class_Object" class. It does not really need
                      //       non-const handle.

                        ooas::Class_Object classObj((ooHandle(ooObj)&)theInputH );
                        if( !classObj ) {
                            cerr << context << "no ooas::Class_Object for the input object reference: " << theInputH.sprint( ) << endl;
                            ::exit( 1 );
                        }

                      // ATTENTION: update the cache _before_ prifiling the object to prevent
                      //            "copy self" loop. This may cause crashes in the code.

                        _dictionary->addObject( theInputH, theInputH );

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << endl;
//}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                        if( !printObjectContents( classObj, prefix )) return false;
                    }
                }
            }
        }
    }

////////////////////////////////////////////////////////////////
if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << " << " << endl;
}
////////////////////////////////////////////////////////////////

    return true;
}

bool
CdbBdbPrintObjectTreeImpl::printObjectContents( const ooas::Class_Object& theClassObject,
                                                             const Prefix& thePrefix )
{
    if( !theClassObject ) {
        cerr << "CdbBdbPrintObjectTreeImpl::printObjectContents() -- an invalid class object passed into the method." << endl;
        ::abort( );
    }

  // Get the class object

    const ooas::d_Class& classDsc = theClassObject.type_of( );

  // We're only interested in a user defined (non-internal) classes.

    if( !classDsc.is_class   ( )) return true;
    if(  classDsc.is_internal( )) return true;

  // Browse all attributes

    {
        attribute_iterator itr = classDsc.defines_attribute_begin( );
        while( classDsc.defines_attribute_end( ) != itr ) {

            const ooas::d_Attribute& attrDsc = *itr;

            if( attrDsc.is_base_class( )) {

///////////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( ) << "BASE CLASS" << endl;
}
///////////////////////////////////////////////////////

                ooas::Class_Object inputClassObj = theClassObject.get_class_obj( attrDsc.position( ));

                printObjectContents( inputClassObj, thePrefix );

            } else if( attrDsc.is_relationship( )) {

                const d_Relationship&     relDsc          = (const d_Relationship&)attrDsc;
                ooas::Relationship_Object relationshipObj =  theClassObject.get_relationship( attrDsc.position( ));
                assert( relationshipObj );  // a consistency bug in the Objectivity/DB Active Schema API

                if( relDsc.is_to_many( )) {

///////////////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( ) << "n-RELATIONSHIP" << endl;
}
///////////////////////////////////////////////////////////

                    uint32 num = 0;     // The cardinality of the association

                    ooItr(ooObj) itr;
                    relationshipObj.get_iterator( itr );

                    while( itr.next( )) {

                        ooHandle(ooObj) inputH;
                        inputH = itr;

                        if( !printObject( inputH )) return false;

                        ++num;
                    }

                } else {

///////////////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( ) << "1-RELATIONSHIP" << endl;
}
///////////////////////////////////////////////////////////

                    ooHandle(ooObj) inputH;
                    inputH = relationshipObj.get_ooref( );

                    if( !printObject(inputH )) return false;
                }

            } else {

                const ooas::d_Type& typeDsc = attrDsc.type_of( );

                size_t fixedArraySize = attrDsc.array_size( );

                if( typeDsc.is_ref_type( )) {

//////////////////////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( ) << "REFERENCE";
    if( fixedArraySize > 1 ) cout << "[" << fixedArraySize << "]";
    cout << endl;
}
//////////////////////////////////////////////////////////////////

                    for( size_t i = 0; i < fixedArraySize; ++i ) {

                        ooHandle(ooObj) inputH;
                        inputH = theClassObject.get_ooref( attrDsc.position( ), i );

                        if( !printObject( inputH )) return false;
                    }

                } else if( typeDsc.is_basic_type( )) {

                    ;

                } else if( typeDsc.is_string_type( )) {     // It may also be an embedded string class,
                                                            // so we make this scheck before the next one.
                    ;

                } else if( typeDsc.is_class( ) && !typeDsc.is_string_type( )) {     // strings may also be represented
                                                                                    // by embedded classes.

//////////////////////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( ) << "EMBEDDED OBJECT";
    if( fixedArraySize > 1 ) cout << "[" << fixedArraySize << "]";
    cout << endl;
}
//////////////////////////////////////////////////////////////////

                    for( size_t i = 0; i < fixedArraySize; ++i ) {

                        ooas::Class_Object inputClassObj = theClassObject.get_class_obj( attrDsc.position( ), i );

                        if( !printObjectContents( inputClassObj, thePrefix )) return false;
                    }

                } else if( typeDsc.is_varray_type( )) {

                    ooas::VArray_Object inputVArrayObject = theClassObject.get_varray( attrDsc.position( ));

                    uint32 varraySize = inputVArrayObject.size( );

                    if( typeDsc.is_varray_basic_type( )) {

                        ;

                    } else if( typeDsc.is_varray_ref_type( )) {

////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( )
         << "V-ARRAY OF REFERENCES" << endl;
}
////////////////////////////////////////////

                        for( uint32 i = 0; i < varraySize; ++i ) {

                            ooHandle(ooObj) inputH;
                            inputH = inputVArrayObject.get_ooref( i );

                            if( !printObject( inputH )) return false;
                        }

                    } else if( typeDsc.is_string_type( )) {     // It may also be an embedded string class,
                                                                // so we make this scheck before the next one.
                        ;

                    } else if(  typeDsc.is_varray_embedded_class_type( ) &&
                               !typeDsc.is_string_type( )) {

//////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( )
         << "V-ARRAY OF EMBEDDED OBJECTS" << endl;
}
//////////////////////////////////////////////////

                      // NOTE: In theory embedded objects should have the same size, so we could
                      //       speed up the profiling. Unfortunatelly it's hard to get this size
                      //       of these objects are of a hierarhical class and/or if these objects
                      //       have external references.
                      //
                      //       Therefore we're using the bruit force method when profiling these
                      //       objects.

                        for( uint32 i = 0; i < varraySize; ++i )
                            if( !printObjectContents(  inputVArrayObject.get_class_obj( i ),
                                                         thePrefix )) return false;

                    } else {

                        bool isKnownTypeOfVarrayElements = false;
                        assert( isKnownTypeOfVarrayElements );
                    }

                } else {

                    bool isKnownType = false;
                    assert( isKnownType );
                }
            }
            ++itr;
        }
    }
    return true;
}

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

---