---

CdbBdbSchemaUtils.hh

Go to the documentation of this file.

#ifndef CDBBDB_SCHEMA_UTILS_HH
#define CDBBDB_SCHEMA_UTILS_HH

// File and Version Information:
//      $Id: CdbBdbSchemaUtils.hh,v 1.4 2004/10/21 20:35:52 gapon Exp $

#include "CdbBase/CdbCommon.hh"

#include <oo.h>

#include <string>
#include <vector>
#include <map>

/// This class provides Objectivity/DB schema services
/**
  * These services are either missing or inproperly implemented in the standard
  * Objectivity/DB C++ API. The current implementation of this class uses the
  * Active Schema API.
  *
  * This class is implemented as the singleton with lazy instantiation.to extract
  * schema information from the federation.
  *
  * The class does _NOT_ do its own transction management. Therefore its client must supply
  * proper transaction environment (READ) when using  this class's methods.
  */
class CdbBdbSchemaUtils {

public:

  /// The internal type identifier
  /**
    * This type is used in the implementation of the current class as a replacement for
    * the non-contigous ooTypeNumber.
    */
    typedef unsigned int LocalTypeID;

  /// The node class in the dependency tree
  /**
    * Each class (type number) is represented by an instance of the Node class
    * having biderectional pointers onto its subclasses and superclasses.
    */
    class Node {

    private:

      // Prohibited constructors

        Node( );
        Node( const Node&);
        Node& operator=( const Node&);

    public:

        Node( const ooTypeNumber theTypeNumber );

    public:

        const ooTypeNumber typeNumber;

        std::map<ooTypeNumber, Node* > subclasses;
        std::map<ooTypeNumber, Node* > superclasses;
    };

  /// Dependency tree class

    class Tree {

        friend class CdbBdbSchemaUtils;

    private:

      // Prohibited constructors

        Tree( const Tree&);
        Tree& operator=( const Tree&);

    public:

        Tree( );
        ~Tree( );

        inline bool isLoaded( ) { return _isLoaded; }

        const Node* type_to_node( const ooTypeNumber theTypeNumber ) const;

    private:

        void reset( );

        bool load( const std::map<ooTypeNumber, std::vector<ooTypeNumber> >& thePartialTree,
                                                                        bool debugModeFlag = false );

        Node* type_to_node( const std::map<ooTypeNumber, std::vector<ooTypeNumber> >& thePartialTree,
                                                                   const ooTypeNumber theTypeNumber,
                                                                                 bool debugModeFlag );
    private:

        bool _isLoaded;

    public:

      // The following map represents entries for all classes to be processed
      // by the algorithm.
      //
      // IMPORTANT NOTE: This data structures has ownership over all the dynamically
      //                 allocated by the current algorithm nodes.

        std::map<ooTypeNumber, Node*> all;

      // The "very base" classes which do not have any base classes.
      // This data structure represents the result of the 

        std::map<ooTypeNumber, Node*> root;
    };

public:

  /// Accessor for the singleton
  /**
    * The very first call to the accessor would instantiate the singleton.
    */
    static CdbBdbSchemaUtils& instance( );

private:

  /// The default constructor
  /**
    * Will load the schema information into the local cache.
    */
    CdbBdbSchemaUtils( );

  /// The copy constructor (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbBdbSchemaUtils( const CdbBdbSchemaUtils& theObject );

  /// The destructor
  /**
    * Would clear up the cache.
    */
    virtual ~CdbBdbSchemaUtils( );

  /// The assignment operator (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbBdbSchemaUtils& operator=( const CdbBdbSchemaUtils& theObject );

public:

  /// Check if one class (specified by its type number) derives from another one
  /**
    * If either of the passed type number is unknown to the current federation's
    * schema then negative result will always be returned.
    *
    * If both types parameters have the same value than positive results always gets
    * returned unless the type number is unknown.
    *
    * @returns a result of the comparision
    */
    bool isA( const ooTypeNumber theDerivedTypeNumber,  /**< the derived type identifier */
              const ooTypeNumber theBaseTypeNumber      /**< its potential base type */
            ) const;

  /// Translate a type number into its class name
  /**
    * The method will return "false" if specified type number is unknown or
    * does not correspond to the class.
    */
    bool typeNumberToClassName( const ooTypeNumber theTypeNumber,   /**< the type number in question */
                                      std::string& theClassName     /**< its class name */
                              ) const;

  /// Translate a class name into its type number
  /**
    * The method will return "false" if specified class name is unknown.
    */
    bool classNameToTypeNumber(   const char* theClassName,         /**< the class name in question */
                                ooTypeNumber& theTypeNumber         /**< its type number  */
                              ) const;

  /// Get dependency tree for all known type numbers
  /**
    * The method (if successfull) would set up a user supplied object with
    * the full tree.
    *
    * @see CdbBdbSchemaUtils::Node
    * @see CdbBdbSchemaUtils::Tree
    */
    bool loadDependencyTree( Tree& theTree ) const;

  /// Update class information from the federation's schema
  /**
    * This method will drop the current object's cache and reload
    * it fresh from the federation.
    *
    * The method will return "false' should any problem occure durinig
    * its execution.
    */
    bool update( );

private:

  /// Clear current cache

    void clearCache( );

  /// Register specified class indictionaries

    void registerClass(  const LocalTypeID theLocalTypeId,
                               const char* theClassName,
                        const ooTypeNumber theTypeNumber
                      );

public:

  // The parameters of the class

    static bool debugMode;

private:

  // These dictionaries provide bi-directional translation
  // between class names and Objectivity/DB type numbers.

    std::map<std::string, ooTypeNumber> _nameToTypeNumber;
    std::map<ooTypeNumber, std::string> _typeNumberToName;

  // These dictionaries poivide bi-directional translation
  // between local (used by the current class) type identifiers
  // and Objectivity/DB type numbers.

    std::map<LocalTypeID, ooTypeNumber> _localTypeIdToTypeNumber;
    std::map<ooTypeNumber, LocalTypeID> _typeNumberToLocalTypeId;

  // A dependency tree of classes

    std::map<ooTypeNumber, std::vector<ooTypeNumber> > _dependencyTree;

  // A square matrix representing the "derived<->base" class relationship graph.
  // This data structure is good for quick finding both direct and indirect base
  // classes (when answering the IS_A questions). However, unlike the dependency
  // tree, it does not reflect original relationship information.
  //
  //   - indeces of the matrix have the same type: LocalTypeID
  //   - the first index of the matrix is the derived class
  //   - the second index is the base class identifier
  //   - only classes (including internal Objectivity/DB classes) are included
  //   - the current size of the matrix is defined through a special variable

         bool** _derivedVsBase;
    LocalTypeID _derivedVsBaseSize;
};

#endif  // CDBBDB_SCHEMA_UTILS_HH

---