---

CdbBdbObjectVisitorContext.hh

Go to the documentation of this file.

#ifndef CDBBDB_OBJECT_VISITOR_CONTEXT_HH
#define CDBBDB_OBJECT_VISITOR_CONTEXT_HH

// File and Version Information:
//      $Id: CdbBdbObjectVisitorContext.hh,v 1.2 2004/10/21 20:35:50 gapon Exp $

#include "CdbBase/CdbCommon.hh"

#include <oo.h>     // ooRef(ooObj), ooHandle(ooObj)

#include <string>
#include <vector>

/// The current context of the objects visitor procedure
/**
  * An object of this class is prepared by the visitor procedure and then
  * is passed down to the user defined action method alongside with an
  * objects to be evaluated in the current context.
  * 
  * IMPLEMENTATION NOTES:
  *
  *   (1) This class violates CDB API convention on the inclusion
  *       of "CdbBase/CdbCommon.hh" header file to avoid STD namespace
  *       conflicts of the kind described above.
  */
class CdbBdbObjectVisitorContext {

public:

  /// An internal elmnet of the contex
 /**
   * More details...
   */
    class Element {

    public:

      /// A kind of an element
      /**
        * These values determine the semantics and usability of other data
        * members of particular elements.
        */
        typedef enum { OBJECT,
                       BASE_CLASS,
                       EMBEDDED_OBJECT,
                       MAP_ELEMENT,
                       REFERENCE,
                       MANY_RELATIONSHIP,
                       ONE_RELATIONSHIP
        } Type;

    private:

      /// Default constructor (NOT IMPLEMENTED)

      /// Universal constructor
      /**
        * This constructor is only meant to be used by 'virtual' c-tors defined below.
        */
        Element(                Type theType,
                 const ooRef(ooObj)& theRef,
                         const char* theName,
                         const char* theName_2,
                              size_t theIndex ) :
            _type  (theType),
            _ref   (theRef),
            _name  (theName),
            _name_2(theName_2),
            _index (theIndex)
        { }

    public:

      // 'Virtual' c-tors

        static Element createObject( const ooRef(ooObj)& theRef,
                                             const char* theClassName )
        {
            return Element( OBJECT,
                            theRef,
                            theClassName,
                            "",
                            0 );
        }
        static Element createBaseClass( const char* theClassName )
        {
            return Element( BASE_CLASS,
                            0,
                            theClassName,
                            "",
                            0 );
        }
        static Element createEmbeddedObject( const char* theClassName,
                                             const char* theName,
                                                  size_t theIndex = 0 )
        {
            return Element( EMBEDDED_OBJECT,
                            0,
                            theClassName,
                            theName,
                            theIndex );
        }
        static Element createMapElement( const char* theKeyName )
        {
            return Element( MAP_ELEMENT,
                            0,
                            theKeyName,
                            "",
                            0 );
        }
        static Element createReference( const char* theName,
                                             size_t theIndex = 0 )
        {
            return Element( REFERENCE,
                            0,
                            theName,
                            "",
                            theIndex );
        }
        static Element createManyRelationship( const char* theName )
        {
            return Element( MANY_RELATIONSHIP,
                            0,
                            theName,
                            "",
                            0 );
        }
        static Element createOneRelationship( const char* theName )
        {
            return Element( ONE_RELATIONSHIP,
                            0,
                            theName,
                            "",
                            0 );
        }

      /// Copy constructor

        Element( const Element& theOther ) :
            _type  (theOther._type),
            _ref   (theOther._ref),
            _name  (theOther._name),
            _name_2(theOther._name_2),
            _index (theOther._index)
        { }

      /// Assignment operator

        Element& operator=( const Element& theOther )
        {
            if( &theOther != this ) {
                _type   = theOther._type;
                _ref    = theOther._ref;
                _name   = theOther._name;
                _name_2 = theOther._name_2;
                _index  = theOther._index;
            }
            return *this;
        }

      // Accessors

        Type type( ) const
        {
            return _type;
        }

        const ooRef(ooObj)& ref( ) const
        {
            return _ref;
        }

        const std::string& name( ) const
        {
            return _name;
        }

        const std::string& name_2( ) const
        {
            return _name_2;
        }

        size_t index( ) const
        {
            return _index;
        }

    private:

                Type _type;
        ooRef(ooObj) _ref;
         std::string _name;
         std::string _name_2;
              size_t _index;
    };

public:

  /// The default constructor
  /**
    * Initializes an empty context
    */
    CdbBdbObjectVisitorContext( );

  /// The destructor
  /**
    * Moe details...
    */
    virtual ~CdbBdbObjectVisitorContext( );

  /// Reset the context to its initial state

    void reset( );

  /// Append ne more element at the end

    void push( const Element& theElement );

  /// Remove the last element (if any) from the very end

    void pop( );

  /// Get to the first element

    const Element& first( ) const;

  /// Get to the last element

    const Element& last( ) const;

  /// Get the total number of elements

    size_t size( ) const;

  /// Access elements using the array kind manner

    const Element& operator[]( size_t theIndex ) const;

private:

    std::vector<Element> _elements;
};

#endif  // CDBBDB_OBJECT_VISITOR_CONTEXT_HH

---