---

CdbOrigin.hh

Go to the documentation of this file.

#ifndef CDB_ORIGIN_HH
#define CDB_ORIGIN_HH

// File and Version Information:
//      $Id: CdbOrigin.hh,v 1.3 2003/08/13 23:34:13 gapon Exp $

#include "BdbTime/BdbTime.hh"

#include "CdbBase/CdbCPtrBase.hh"
#include "CdbBase/CdbOriginPtrFwd.hh"
#include "CdbBase/CdbDatabasePtrFwd.hh"

#include "CdbBase/CdbItr.hh"

#include <string>

class CdbProperty;

/// The transient interface to an origin object.
/**
  * More details to come...
  */
class CdbOrigin {

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

private:

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

  /// The copy constructor (NOT IMPLEMENTED)
  /**
    * Is disabled...
    */
    CdbOrigin( const CdbOrigin& theOrigin );

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

protected:

  /// The normal constructor.
  /**
    * Initialize context with specified parameters.
    *
    * @see CdbDatabase
    * @see CdbDatabasePtr
    */
    CdbOrigin( const CdbDatabasePtr& theDatabasePtr,    /**< the smart pointer providing a back back link to the parent database object */
               const char*           theName,           /**< the name of the origin */
               unsigned short        theId              /**< the identifier of the origin */
             );

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

public:

  /// The static locator for an origin object (by name)
  /**
    * This locator uses the name of the origin to resolve the right
    * instance of the origin 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 CdbOrigin
    * @see CdbOriginPtr
    *
    * @return the completion status of the operation
    */
    static CdbStatus instance( CdbOriginPtr& theOriginPtr,
                               const char*   theOriginName,
                               const char*   theDatabaseName       = 0,     /**< the database name */
                               const char*   theImplementationName = 0,     /**< the implementation name */
                               const char*   theTechnologyName     = 0      /**< the technology name */
                             );

  /// The static locator for an origin object (by id)
  /**
    * This locator is similar to teh one defined above. It just uses an identifier
    * instead of a name.
    */
    static CdbStatus instance( CdbOriginPtr&  theOriginPtr,
                               unsigned short theOriginId,
                               const char*    theDatabaseName       = 0,    /**< the database name */
                               const char*    theImplementationName = 0,    /**< the implementation name */
                               const char*    theTechnologyName     = 0     /**< the technology name */
                             );

public:

  /// Return a smart pointer to the parent database object.
  /**
    * @see CdbDatabase
    * @see CdbDatabasePtr
    */
    const CdbDatabasePtr& parent( ) const;

  /// The name of an object
  /**
    * @return a non-0 pointer onto a string owned by the object.
    */
    const char* name( ) const;

  /// Obtain the creation time of the origin
  /**
    * This method is supposed to be implemented by the corresponding subclass.
    *
    * @return a string with the object's description
    */
    virtual BdbTime created( ) = 0;

  /// Obtain the origin description
  /**
    * This method is supposed to be implemented by the corresponding subclass.
    *
    * @return a string with the object's description
    */
    virtual std::string description( ) = 0;

  /// The identifier of an object
  /**
    * @return a value of the identifier.
    */
    unsigned short id( ) const;

  /// Check if this origin is the local one
  /**
    * The "local" origin is the one corresponding to the part of a distributed database setup
    * currently being used by a client application. This database also can be called the "local" one.
    * Depending on the origin's type "local" databases (=origins) may have persistent resources
    * modifiable by clients' applications. The actual set on those resources depends on
    * the origin's type.
    *
    * This method is supposed to be implementyed by subclasses.
    *
    * @return TRUE if this is the "local" origin
    */
    virtual bool isLocal( ) const = 0;

  /// Check if data corresponding to this origin are available in the local database
  /**
    * The positive answer means that the data from remote database have already been brought
    * into local database.
    *
    * This method is supposed to be implementyed by subclasses.
    *
    * @return TRUE if this is the "local" origin
    */
    virtual bool isInstantiated( ) const = 0;

  /// Check if this origin is the "master" one
  /**
    * The "master" origin is meant to describe the central database of a distributed database setup.
    * Certain database operations can only be performed in this central "master" database.
    *
    * This method is supposed to be implemented by subclasses.
    *
    * @return TRUE if this is the "master" origin
    */
    virtual bool isMaster( ) const = 0;

  /// Check if this origin is a "slave" one
  /**
    * The "slave" origin is meant to describe a database being a part of a distributed database setup.
    * The database of the "slave" origin is allowed to contribute data into the distrubuted
    * database so that these data can be seen and used by clients of other databases of the setup.
    * The "slave" origin is known to its central "master" database. The "master" may delegate certain
    * operations to its "slave"-s.
    *
    * This method is supposed to be implemented by subclasses.
    *
    * @return TRUE if this is the "slave" origin
    */
    virtual bool isSlave( ) const = 0;

  /// Check if this origin is a "test" one
  /**
    * The "test" origin is meant to describe a database NOT being a part of a distributed database setup.
    * The database of the "test" origin is NOT allowed to contribute data into the distrubuted
    * database in a way it's done by "slave" databases. However the "test" type databases are allowed
    * to produce their own local data to be consumed locally. It's allso allowed to import data from
    * the corresponding distributed database.
    *
    * This method is supposed to be implemented by subclasses.
    *
    * @return TRUE if this is the "test" origin
    */
    virtual bool isTest( ) const = 0;

  /// Set up an iterator of properties
  /**
    * Specific implementations of this origin class my supply technology- and 
    * implementation- specific properties.
    *
    * This method is supposed to be implemented by subclasses.
    *
    * @see CdbProperty
    *
    * @return CdbStatus::Success if the iterator is set up
    */
    virtual CdbStatus propertyIterator( CdbItr<CdbProperty>& theItr /**< the iterator to set up */
                                      ) = 0;

private:

    CdbDatabasePtr _myParent;
    std::string    _myName;
    unsigned short _myId;
};

#endif  // CDB_ORIGIN_HH

---