---

CdbObject.hh

Go to the documentation of this file.

#ifndef CDB_OBJECT_HH
#define CDB_OBJECT_HH

// File and Version Information:
//      $Id: CdbObject.hh,v 1.14 2005/09/08 00:59:32 gapon Exp $

#include "BdbTime/BdbTime.hh"

#include "CdbBase/CdbCPtrBase.hh"
#include "CdbBase/CdbCPtr.hh"
#include "CdbBase/CdbObjectPtrFwd.hh"
#include "CdbBase/CdbConditionPtrFwd.hh"
#include "CdbBase/CdbType2Id.hh"
#include "CdbBase/CdbObjectTranslator.hh"

class CdbStateId;

/// The transient interface to a condition object.
/**
  * More details to come...
  */
class CdbObject {

friend class CdbCPtrBase< CdbObject >;  // Who destroys me

private:

  /// The constructor (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbObject( );

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

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

protected:

  /// The normal constructor.
  /**
    * Initialize context with specified parameters.
    *
    * @see CdbCondition
    * @see CdbConditionPtr
    * @see BdbTime
    */
    CdbObject( const CdbConditionPtr& theConditionPtr,          /**< the smart pointer providing a back back link to the parent condition object */
               const BdbTime&         theBeginOriginalValidity, /**< a point where the object's 'original' validity begins from */
               const BdbTime&         theEndOriginalValidity,   /**< ... and finishes (exclusing) at */
               const BdbTime&         theBeginValidity,         /**< a point where the object's 'visible' validity begins from */
               const BdbTime&         theEndValidity,           /**< ... and finishes (exclusing) at */
               const BdbTime&         theBeginDuration,         /**< a point where the object's duration at insertin time begins from */
               const BdbTime&         theEndDuration,           /**< ... and finishes (exclusing) at */
               const BdbTime&         theInsertionTime          /**< the time when an object was inserted */
             );

  /// The destructor.
  /**
    * More details...
    */
    virtual ~CdbObject( );

public:

  /// The static locator for a condition object
  /**
    * This locator uses the "state identifier" to resolve the right
    * instance of the condition object in the scope of a database.
    *
    * The database itself as well as the top-level API object are two
    * optional parameters of this method. If either (or both) of them are
    * not specified then the corresponding default values will be used.
    *
    * @see CdbObjectPtr
    * @see BdbTime
    * @see CdbStateId
    *
    * @return the completion status of the operation
    */
    static CdbStatus instance( CdbObjectPtr&     theObjectPtr,
                               const char*       theFullPath,
                               const BdbTime&    theValidityTime,
                               const CdbStateId& theStateId,                /**< NOTE: the view identifier is encoded here */
                               const char*       theDatabaseName       = 0, /**< the database name */
                               const char*       theImplementationName = 0, /**< the implementation name */
                               const char*       theTechnologyName     = 0  /**< the technology name */
                             );

  /// Convert into a transient form
  /**
    * The method will try to find and use a "persistnet-to-transient" translator
    * to produce a transient object of the specified (by the pointer) type. The translator
    * is supposed to be registered with the top-level CDB API object of the current
    * "technology" and "implementation".
    *
    * @see Cdb::registerTranslator()
    * @see Cdb::convertToTransient()
    */
    template< class T >
    static CdbStatus transient( T*&                 theTransientPtr,
                                const CdbObjectPtr& theObjectPtr )
    {
        if( theObjectPtr.isNull( )) return CdbStatus::IllegalParameters;

      // Find the translator matching a pair of the desired transient and the actual
      // persistent types.

        CdbCPtr<CdbObjectTranslator> translatorPtr;
        CdbStatus result = findTranslator( translatorPtr,
                                           CdbType2Id<T>::id( ),
                                           theObjectPtr );
        if( CdbStatus::Success != result ) return result;

      // Proceed with the found translator.

        return translatorPtr->transient( theTransientPtr,
                                         theObjectPtr );
    }

private:

  /// Find a user defined "persistent-to-transient" translator (helper)
  /**
    * That's essentially a redirection to the Cdb::findTranslator() method meant
    * to break a potential circular dependency between CdbObject and Cdb classes,
    * and to avoid doing non-specific operations in the Cdb class.
    *
    * @see Cdb::findTranslator()
    */
    static CdbStatus findTranslator( CdbCPtr<CdbObjectTranslator>& theTranslatorPtr,
                                     unsigned int                  theTransientTypeId,
                                     const CdbObjectPtr&           theObjectPtr );
public:

  /// Return a smart pointer to the parent condition object.
  /**
    * @see CdbCondition
    * @see CdbConditionPtr
    */
    const CdbConditionPtr& parent( ) const;

  /// The beginning of the "original" validity interval of an object
  /**
    * @see BdbTime
    */
    const BdbTime& beginOriginal( ) const;

  /// The end of the "original" validity interval of an object
  /**
    * @see CdbObject::beginOriginal()
    */
    const BdbTime& endOriginal( ) const;

  /// The beginning of the "visible" validity interval of an object
  /**
    * NOTE: that the difference between the "visible" validity interval of an object and
    * the validity interval it was originally stored with in the database. The "visible"
    * validity interval is how the object was seen in the database when iy was fetched
    * from it at specific revision level. This interval may get shorten (or even completelly
    * overshadowed) as new objects are stored in a condition.
    * Meanwhile the original (stored) validity never changes.
    *
    * @see BdbTime
    */
    const BdbTime& begin( ) const;

  /// The end of the "visible" validity interval of an object
  /**
    * @see CdbObject::begin()
    */
    const BdbTime& end( ) const;

  /// The beginning of the "duration" interval of an object at the insertion dimension
  /**
    * The "duration" interval is 
    *
    * @see BdbTime
    */
    const BdbTime& beginDuration( ) const;

  /// The end of the "duration" interval of an object at the insertion dimension
  /**
    * @see CdbObject::beginDuration()
    */
    const BdbTime& endDuration( ) const;

  /// The insertion time of an object
  /**
    * This is an actual time when an object was stored in the database.
    *
    * @see BdbTime
    */
    const BdbTime& inserted( ) const;

  /// An object identifier
  /**
    * The contents and the semantic of the string is defined by the underlying
    * persistent technology.
    *
    * The method has to be implemented by a subclass.
    */
    virtual std::string id( ) const = 0;

    /// A 'legacy' object identifier
  /**
    * The contents and the semantic of the string is defined by the underlying
    * persistent technology.
    *
    * The method has to be implemented by a subclass.
    */
    virtual std::string legacyId( ) const = 0;

  /// A persistent type name
  /**
    * The contents and the semantic of the string is defined by the underlying
    * persistent technology.
    *
    * The method has to be implemented by a subclass.
    */
    virtual std::string type( ) const = 0;

private:

    CdbConditionPtr _myParent;

    BdbTime _beginOriginalValidity;
    BdbTime _endOriginalValidity;
    BdbTime _beginValidity;
    BdbTime _endValidity;
    BdbTime _beginDuration;
    BdbTime _endDuration;

    BdbTime _inserted;
};

#endif  // CDB_OBJECT_HH

---