---

CdbTransaction.hh

Go to the documentation of this file.

#ifndef CDB_TRANSACTION_HH
#define CDB_TRANSACTION_HH

// File and Version Information:
//      $Id: CdbTransaction.hh,v 1.1 2005/02/02 13:54:56 gapon Exp $

#include "CdbBase/CdbTransactionBase.hh"
#include "CdbBase/CdbPtrFwd.hh"

/// The transaction management front-end
/**
  * This is a technology neutral front-end class to technology specific
  * implementations of the transaction management based on the
  * "resource-acquisition-is-initialization" paradigm.
  *
  * The transaction is started when a constructor of the class
  * is invoked, and is commited when the destructor is executed.
  * The desired transaction mode can be passed as an optional parameter
  * of the class's constructor.
  *
  * This paradigme lets us to implement the following code pattern:
  *
  *     // Begin a block of code (can be a function, a method, etc.)
  *
  *       {
  *           CdbTransaction trans;  // begin a transaction in default mode,
  *                                  // which is CdbTransaction::Read.
  *           ...
  *       }
  *
  *     // It's guaranteed that the transaction is always returned into the same
  *     // state it was before entering the block when the execution leaves
  *     // the block, no matter what happens to the control flow.
  *
  * The main benefit of this approach is that a user should not warry about
  * explicit matching each "start transaction" with the corresponding "end transaction",
  * which in some cases may introduce an extra "noise" into the logic of the code.
  * So the only extra action to be made is to provide a block and to declare a variable
  * of this class in an appropriate place of the block (usually at its very beginninig).
  *
  * Here is another example, requering the names of specific CDB API "technology" and
  * "implementation" be specified:
  *
  *     // Begin a block of code (can be a function, a method, etc.)
  *
  *       {
  *           CdbTransaction trans( "SomeTechnology",
  *                                 "SomeImplementation",
  *                                 CdbTransaction::Update );
  *           ...
  *       }
  *
  * @see class CdbTransactionBase
  */
class CdbTransaction : public CdbTransactionBase {

public:

  /// Modes of transactions

    enum Mode { Read, Update };

private:

  /// Copy constructor (NOT IMPLEMENTED)

    CdbTransaction( const CdbTransaction& );

  /// Assignment operator (NOT IMPLEMENTED)

    CdbTransaction& operator=( const CdbTransaction& );

public:

  /// The constructor
  /**
    * Make sure that there is a transaction started in the specified mode.
    *
    * The operation is performed in a scope of the default CDB API implementation
    * fetched through the top-level CDB API class: Cdb.If the default implementation
    * won't be found then the crash in the constructor will take place.
    *
    * @see CdbTransactionBase::CdbTransactionBase()
    * @see class Cdb
    */
    explicit CdbTransaction( CdbTransaction::Mode theMode = CdbTransaction::Read );

  /// The constructor
  /**
    * Make sure that there is a transaction started in the specified mode.
    *
    * The operation is performed in a scope of an explicitly specified CDB API implementation.
    * A non-zero pointer is expected. If not then the crash in the constructor will take place.
    *
    * @see CdbTransactionBase::CdbTransactionBase()
    * @see class Cdb
    */
    explicit CdbTransaction( const CdbPtr&        thePtr,
                             CdbTransaction::Mode theMode = CdbTransaction::Read );

  /// The constructor
  /**
    * Make sure that there is a transaction started in the specified mode.
    *
    * The operation is performed in a scope of an explicitly specified CDB API implementation.
    * If the desired implementation won't be found then the crash in the constructor will
    * take place.
    *
    * NOTE ON PARAMETERS:
    *
    * - zero (0) pointer(s) passed where the "technology" and/or "implementation" names are expected
    *   would imply the default value(s) of the parameter(s).
    *
    * @see CdbTransactionBase::CdbTransactionBase()
    * @see class Cdb
    */
    CdbTransaction( const char*          theTechnologyName,
                    const char*          theImplementationName,
                    CdbTransaction::Mode theMode = CdbTransaction::Read );

  /// The destructor
  /**
    * Return current transaction into the same state if was before instantiating
    * an object of the class.
    *
    * @see CdbTransactionBase::~CdbTransactionBase()
    */
    ~CdbTransaction( );

  /// Flush modifications made within the current transaction and keep going
  /**
    * Implements the corresponding method defined in a base class or an interface.
    *
    * @see CdbTransactionBase::commitAndHold()
    */
    void commitAndHold( );

private:

  // The actual implementation of the transaction manager

    CdbTransactionBase* _myImplPtr;
};

#endif  // CDB_TRANSACTION_HH

---