---

CdbBdbSchemaUtils.cc

Go to the documentation of this file.

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

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

#include "BaBar/BaBar.hh"

#include "CdbBdb/CdbBdbSchemaUtils.hh"

#include <ooas.h>

#include <assert.h>

#include <iostream>
#include <iomanip>
using std::cerr;
using std::cout;
using std::endl;
using std::setfill;
using std::setw;

namespace {

  /// Browse the class description and find build its partial dependency tree
  /**
    * The function will browse through the hierarchy of the specified class to
    * find its base classes (including internal ones defined by Objectivity/DB).
    *
    * According to the definition of the tree, a class can't be defined
    * to be a base class to itself.
    *
    * The results will be put into the supplied dependency tree.
    *
    * @return the "true" if the operation finished successfully.
    */
    bool buildPartialDependencyTreeForClass(                                const ooas::d_Class& theClassDsc,
                                             std::map<ooTypeNumber, std::vector<ooTypeNumber> >& theDependencyTree )
    {
        if( !theClassDsc ) return false;

        ooTypeNumber classTypeNumber = theClassDsc.id( );

      // Skip already analysed classes

        if( theDependencyTree.end( ) != theDependencyTree.find( classTypeNumber )) return true;

      // Initialize an empty entry in the tree for the current type

        theDependencyTree[classTypeNumber] = std::vector<ooTypeNumber>( );

      // Now look into base classes

        ooas::attribute_iterator attributeItr = theClassDsc.defines_attribute_begin( );
        while( attributeItr != theClassDsc.defines_attribute_end( )) {

            const ooas::d_Attribute& attrDsc = *attributeItr;
            if( attrDsc.is_base_class( )) {

                const ooas::d_Class& baseClassDsc = attrDsc.class_type_of( );

              // Updated supplied data structures

                ooTypeNumber baseClassTypeNumber = baseClassDsc.id( );

                theDependencyTree[classTypeNumber].push_back( baseClassTypeNumber );

              // Proceed down to the found base class

                if( !buildPartialDependencyTreeForClass( baseClassDsc,
                                                         theDependencyTree )) return false;
            }
            ++attributeItr;
        }
        return true;
    }

  /// Fill the dependency matrix for specified derived class
  /**
    * This is a recursive algorithm filing the dependency matrix from the dependency
    * tree. According to the definition of the matrix, a class can't be defined
    * to be a base class to itself.
    */
    void fillDependencyMatrixForClass(                                                           ooTypeNumber theDerivedClassTypeNumber,
                                                                                                 ooTypeNumber theBaseClassTypeNumber,
                                                      std::map<ooTypeNumber, CdbBdbSchemaUtils::LocalTypeID>& theTypeNumberToLocalTypeId,
                                                          std::map<ooTypeNumber, std::vector<ooTypeNumber> >& theDependencyTree,
                                                                                                       bool** derivedVsBase )
    {
        const std::vector<ooTypeNumber>* baseClasses = &(theDependencyTree[theBaseClassTypeNumber]);

        size_t num = (*baseClasses).size( );
        for( size_t i = 0; i < num; ++i )
            fillDependencyMatrixForClass( theDerivedClassTypeNumber,
                                          (*baseClasses)[i],
                                          theTypeNumberToLocalTypeId,
                                          theDependencyTree,
                                          derivedVsBase );

      // According to the defenition of the dependency matrix
      // the class can't be base to itself in this data structures.

        if( theDerivedClassTypeNumber != theBaseClassTypeNumber ) {;

            CdbBdbSchemaUtils::LocalTypeID derived = theTypeNumberToLocalTypeId[theDerivedClassTypeNumber];
            CdbBdbSchemaUtils::LocalTypeID base    = theTypeNumberToLocalTypeId[theBaseClassTypeNumber];

            derivedVsBase[derived][base] = true;
        }
    }
};

////////////////////
// NESTED CLASSES //
////////////////////

CdbBdbSchemaUtils::Node::Node( const ooTypeNumber theTypeNumber ) :
    typeNumber(theTypeNumber)
{ }

CdbBdbSchemaUtils::Tree::Tree( ) :
    _isLoaded(false)
{ }

CdbBdbSchemaUtils::Tree::~Tree( )
{
    reset( );
}

const CdbBdbSchemaUtils::Node*
CdbBdbSchemaUtils::Tree::type_to_node( const ooTypeNumber theTypeNumber ) const
{
    if( !_isLoaded ) {
        cerr << "CdbBdbSchemaUtils::Tree::type_to_node() - ERROR." << endl
             << "    Inproper use of a non-loaded dependency tree object. Check if the caller" << endl
             << "    application has explicitly requested to load the tree." << endl;
        return 0;
    }
    std::map<ooTypeNumber, Node*>::const_iterator itr = all.find( theTypeNumber );
    return ( all.end( ) == itr ? 0 : itr->second );
}

void
CdbBdbSchemaUtils::Tree::reset( )
{
   _isLoaded = false;

    std::map<ooTypeNumber, Node*>::iterator itr = all.begin( );
    while( all.begin( ) != itr ) {
        delete itr->second;
        ++itr;
    }
    all.clear( );
    root.clear( );
}

bool
CdbBdbSchemaUtils::Tree::load( const std::map<ooTypeNumber, std::vector<ooTypeNumber> >& thePartialTree,
                                                                                    bool debugModeFlag )
{
    reset( );

  // Build a list of "very base" classes which do not have any base classes.

    std::map<ooTypeNumber, std::vector<ooTypeNumber> >::const_iterator itr = thePartialTree.begin( );
    while( thePartialTree.end( ) != itr ) {

        // Node* node =
        type_to_node( thePartialTree,
                      itr->first,
                      debugModeFlag );
        ++itr;
    }

    _isLoaded = true;

    return true;
}

CdbBdbSchemaUtils::Node*
CdbBdbSchemaUtils::Tree::type_to_node( const std::map<ooTypeNumber, std::vector<ooTypeNumber> >& thePartialTree,
                                                                              const ooTypeNumber theTypeNumber,
                                                                                            bool debugModeFlag )
{
    assert( !_isLoaded );  // a bug in the current class's implementation

    Node* thisNode = 0;
    do {

      // Verify parameters. Opimize access to the partial tree element.

        std::map<ooTypeNumber, std::vector<ooTypeNumber> >::const_iterator partialItr = thePartialTree.find( theTypeNumber );
        if( thePartialTree.end( ) == partialItr ) {

            cerr << "CdbBdbSchemaUtils::Tree::type_to_node() - FATAL INTERNAL ERROR" << endl
                 << "    Inconsistent schema information got from the federation. Something" << endl
                 << "    may be broken in the current code's implementation." << endl
                 << "    The input type number is: " << theTypeNumber << endl;

            ::abort( );
        }

      // Skip the input type if it's alredy procssed

        std::map<ooTypeNumber, Node*>::iterator itr = all.find( theTypeNumber );
        if( all.end( ) != itr ) {

            thisNode = itr->second;

////////////////////////////////////////////////////////////////////////////////////
if( debugModeFlag ) {
cout << "Tree::type_to_node() ALREADY PROCESSED TYPE " << theTypeNumber << endl;
}
////////////////////////////////////////////////////////////////////////////////////

            break;
        }

      // Create and register a node for the type

        thisNode = new Node( theTypeNumber );
        all[theTypeNumber] = thisNode;

      // Check if it's a very base class (no subclasses). Put it into a separate
      // data structure.

        int numBase = partialItr->second.size( );
        if( 0 == numBase ) {

            root[theTypeNumber] = thisNode;

////////////////////////////////////////////////////////////////////////////
if( debugModeFlag ) {
cout << "Tree::type_to_node() VERY BASE TYPE " << theTypeNumber << endl;
}
////////////////////////////////////////////////////////////////////////////
            break;
        }

      // Register this node as a subclass of its imediate base types

///////////////////////////////////////////////////////////////////////////
if( debugModeFlag ) {
cout << "Tree::type_to_node() SUBCLASS TYPE " << theTypeNumber << endl;
}
///////////////////////////////////////////////////////////////////////////

        for( int i = 0; i < numBase; ++i ) {

            ooTypeNumber baseTypeNumber = partialItr->second[i];
                   Node* baseNode       = type_to_node( thePartialTree,
                                                        baseTypeNumber,
                                                        debugModeFlag );

            baseNode->subclasses  [ theTypeNumber] = thisNode;
            thisNode->superclasses[baseTypeNumber] = baseNode;

////////////////////////////////////////////////////////////////////////////////
if( debugModeFlag ) {
cout << "Tree::type_to_node()   ADDED BASE TYPE " << baseTypeNumber << endl;
}
////////////////////////////////////////////////////////////////////////////////
        }

    } while( false );

    return thisNode;
}

////////////////
// HOST CLASS //
////////////////

bool
CdbBdbSchemaUtils::debugMode = false;

CdbBdbSchemaUtils&
CdbBdbSchemaUtils::instance( )
{
    static CdbBdbSchemaUtils myInstance;
    return myInstance;
}

CdbBdbSchemaUtils::CdbBdbSchemaUtils( ) :
    _derivedVsBase    (0),
    _derivedVsBaseSize(0)
{
    if( !update( )) {
        cerr << "CdbBdbSchemaUtils::CdbBdbSchemaUtils( ) - FATAL INTERNAL ERROR IN THE CONSTRUCTOR." << endl
             << "    Unable to load/update schema information from the current federation." << endl;
        ::abort( );
    }
}

CdbBdbSchemaUtils::~CdbBdbSchemaUtils( )
{
    clearCache( );
}

bool
CdbBdbSchemaUtils::isA( const ooTypeNumber theDerivedTypeNumber,
                        const ooTypeNumber theBaseTypeNumber ) const
{
  // Check if these types are known to the schema. Get the local
  // identifiers for these types.

    std::map<ooTypeNumber, LocalTypeID>::const_iterator derivedItr = _typeNumberToLocalTypeId.find( theDerivedTypeNumber );
    std::map<ooTypeNumber, LocalTypeID>::const_iterator    baseItr = _typeNumberToLocalTypeId.find(    theBaseTypeNumber );

    if( _typeNumberToLocalTypeId.end( ) == derivedItr ) return false;
    if( _typeNumberToLocalTypeId.end( ) ==    baseItr ) return false;
    
    LocalTypeID derived = derivedItr->second;
    LocalTypeID base    =    baseItr->second;

  // Return result

    return ( derived == base ) || _derivedVsBase[derived][base];
}

bool
CdbBdbSchemaUtils::typeNumberToClassName( const ooTypeNumber theTypeNumber,
                                                std::string& theClassName ) const
{
    std::map<ooTypeNumber, std::string>::const_iterator classNameItr = _typeNumberToName.find( theTypeNumber );
    if( _typeNumberToName.end( ) != classNameItr ) {
        theClassName = classNameItr->second;
        return true;
    }
    return false;
}

bool
CdbBdbSchemaUtils::classNameToTypeNumber(   const char* theClassName,
                                          ooTypeNumber& theTypeNumber ) const
{
    if( 0 == theClassName ) return false;

    std::map<std::string, ooTypeNumber>::const_iterator typeNumberItr = _nameToTypeNumber.find( std::string( theClassName ));
    if( _nameToTypeNumber.end( ) != typeNumberItr ) {
        theTypeNumber = typeNumberItr->second;
        return true;
    }
    return false;
}

bool
CdbBdbSchemaUtils::loadDependencyTree( Tree& theTree ) const
{
    return theTree.load( _dependencyTree,
                         debugMode );
}

bool
CdbBdbSchemaUtils::update( )
{
    clearCache( );

  // Pass I: Browse the schema and fill up dictionaries for classes.

    const ooas::d_Module& topModule = ooas::d_Module::top_level( );

/////////////////////////////////////////////////////////////////////////////////////////////////////
if( debugMode ) {
    cout << "MODULE: NAME=\"" << topModule.name( ) << "\", ID=" << topModule.id( ) << endl;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////

    ooas::meta_object_iterator metaObjectItr = topModule.defines_begin( );
    while( metaObjectItr != topModule.defines_end( )) {

        const ooas::d_Meta_Object& metaObject = *metaObjectItr;
        if( metaObject.is_module( )) {

            const ooas::d_Module& module = (const ooas::d_Module&)metaObject;

///////////////////////////////////////////////////////////////////////////////////////////////
if( debugMode ) {
    cout << "MODULE: NAME=\"" << module.name( ) << "\", ID=" << module.id( ) << endl;
}
///////////////////////////////////////////////////////////////////////////////////////////////

            ooas::type_iterator typeItr = module.defines_types_begin( );
            while( typeItr != module.defines_types_end( )) {

                const ooas::d_Type& type = *typeItr;
                if( type.is_class( )) {

                    const ooas::d_Class& classType = (const ooas::d_Class&)type;

                    registerClass( _derivedVsBaseSize++,
                                   classType.name( ),
                                   classType.type_number( ));
                }
                ++typeItr;
            }

        } else if( metaObject.is_class( )) {    // We're only interested in classes. In reality
                                                // there are also modules, basic types, references,
                                                // associations, etc.
                                                // To catch them we'd need to ask ::is_type().

            const ooas::d_Class& classType = (const ooas::d_Class&)metaObject;

            registerClass( _derivedVsBaseSize++,
                           classType.name( ),
                           classType.type_number( ));
        }
        ++metaObjectItr;
    }

//////////////////////////////////////////////////////////////////////////////////////////
if( debugMode ) {
    cout << "TOTAL OF " << _derivedVsBaseSize << " classes were found." << endl;
}
//////////////////////////////////////////////////////////////////////////////////////////

  // Create and initialize the matrix representing dependancy graph for
  // found classes.

    _derivedVsBase = new bool*[_derivedVsBaseSize];
    for( LocalTypeID derived = 0; derived < _derivedVsBaseSize; ++derived ) {

        _derivedVsBase[derived] = new bool[_derivedVsBaseSize];
        for( LocalTypeID base = 0; base < _derivedVsBaseSize; ++base ) {

            _derivedVsBase[derived][base] = false;
        }
    }

  // Pass II: Browse the schema of each class and fill up the dependency
  //          tree for each found class.

    {
        std::map<ooTypeNumber, std::string>::iterator classTypeNumberItr = _typeNumberToName.begin( );
        while( classTypeNumberItr != _typeNumberToName.end( )) {

            ooTypeNumber classTypeNumber = classTypeNumberItr->first;
            if( !::buildPartialDependencyTreeForClass( topModule.resolve_class( classTypeNumber ),
                                                       _dependencyTree )) {

                cerr << "CdbBdbSchemaUtils::update( ) - ERROR." << endl
                     << "    Unable to obtain schema information for the class with type number: " << classTypeNumber << endl;
                return false;
            }
            ++classTypeNumberItr;
        }
    }

  // Pass III: Browse the dependancy tree for each class and fill up the dependency
  //           matrix
    
    {
        std::map<ooTypeNumber, std::vector<ooTypeNumber> >::iterator classTypeNumberItr = _dependencyTree.begin( );
        while( classTypeNumberItr != _dependencyTree.end( )) {

            ooTypeNumber classTypeNumber = classTypeNumberItr->first;

            fillDependencyMatrixForClass( classTypeNumber,
                                          classTypeNumber,
                                          _typeNumberToLocalTypeId,
                                          _dependencyTree,
                                          _derivedVsBase );
            ++classTypeNumberItr;
        }
    }

    return true;
}

void
CdbBdbSchemaUtils::clearCache( )
{
    _nameToTypeNumber.clear( );
    _typeNumberToName.clear( );

    _localTypeIdToTypeNumber.clear( );
    _typeNumberToLocalTypeId.clear( );

    _dependencyTree.clear( );

    for( LocalTypeID i = 0; i < _derivedVsBaseSize; ++i ) delete [] _derivedVsBase[i];
    delete [] _derivedVsBase;

    _derivedVsBase     = 0;
    _derivedVsBaseSize = 0;
}

void
CdbBdbSchemaUtils::registerClass(  const LocalTypeID theLocalTypeId,
                                         const char* theClassName,
                                  const ooTypeNumber theTypeNumber )
{
    std::string className = theClassName;

    _nameToTypeNumber[className]     = theTypeNumber;
    _typeNumberToName[theTypeNumber] = className;

    _localTypeIdToTypeNumber[theLocalTypeId] = theTypeNumber;
    _typeNumberToLocalTypeId[theTypeNumber]  = theLocalTypeId;

///////////////////////////////////////////////////////////////////////
if( debugMode ) {
    cout << "  "
         << setw(10) << setfill( ' ' ) << theLocalTypeId
         << " : "
         << setw(10) << setfill( ' ' ) << theTypeNumber
         << " : "
         << "\"" << theClassName << "\"" << endl;
}
///////////////////////////////////////////////////////////////////////
}

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

---