anna::timex::Context< Tid > Class Template Reference

#include <Context.hpp>

Inheritance diagram for anna::timex::Context< Tid >:

Collaboration diagram for anna::timex::Context< Tid >:

Public Member Functions
Transaction *	open (const Tid &tid, const int classType=0) noexcept(false)
Transaction *	find (const Tid &tid, const Exception::Mode::_v emode=Exception::Mode::Throw) noexcept(false)
const Tid &	getIdentifier (const Transaction *transaction) const noexcept(false)
void	close (Transaction *transaction)
virtual xml::Node *	asXML (xml::Node *parent) const
Public Member Functions inherited from anna::timex::TimeEventObserver
	TimeEventObserver (const char *name)
std::string	asString () const

Static Public Member Functions
static const Context *	getInstance (const Transaction *transaction) noexcept(false)

Protected Member Functions
	Context (const char *observerName, timex::Engine &timeController, const Millisecond &timeout)
virtual Transaction *	createTransaction (const int classType)=0
virtual void	releaseTransaction (Transaction *transaction)=0
virtual std::string	identifierAsString (const Tid &tid) const =0
virtual const Tid &	contextAsIdentifier (const void *tid) const =0

Detailed Description

template<typename Tid>
class anna::timex::Context< Tid >

Automatiza todas las operaciones relacionadas con el control de las transaciones de nuestra aplicación.

Parameters

Tid

Indica el tipo de dato usado para ordenar las transaciones en el contexto. Es distinto del identificador de transacción. El identificador de transacción facilita su localización en los niveles de plataforma, mientras que este Tid facilita su localización a niveles de aplicación. Habitualmente este Tid será una cadena alfanumérica.

Warning

• El contexto asociado a la anna::timex::Transaction no puede ser usado al nivel de aplicación, ya que esta clase lo usa internamente.
• No se puede establecer un observador para estas transaciones ya que de otro modo el contexto no podría seguir la pista de las operaciones realizadas sobre ella.

El tipo de dato Tid debe tener los operadores requeridos para actuar como clave de una map <Tid, Transaction>

Constructor & Destructor Documentation

Context()

template<typename Tid >

anna::timex::Context< Tid >::Context ( const char *  observerName, timex::Engine &  timeController, const Millisecond &  timeout  )

inlineprotected

Constructor.

Parameters

observerName	Esta clase hera de anna::timex::TimeEventObserver por lo que debe tener un nombre lógico
timeController	Gestor de temporización usado en la aplicación.
timeout	Duración de las transaciones creadas por el contexto. En principio todas las transaciones tendrán la misma duración, pero en próximas versiones se podría ampliar la funcionalidad para que cada transación pueda indicar su duración de forma independiente.

                                                                                             :
    TimeEventObserver(observerName),
    a_timeController(timeController),
    a_timeout(timeout) {
    a_counter = a_accDelay = a_accSize = 0;
  }

Here is the call graph for this function:

Member Function Documentation

asXML()

template<typename Tid >

virtual xml::Node* anna::timex::Context< Tid >::asXML ( xml::Node *  parent ) const

inlinevirtual

Devuelve la información relevante de esta clase en forma de documento XML.

Parameters

parent

Nodo XML del que colgar la información de esta instancia.

Returns

Un documento XML con la información relevante de esta clase.

  {
    xml::Node* result = parent->createChild("timex.Context");
    result->createAttribute("Size", a_transactions.size());
    result->createAttribute("AvgSize", (a_counter == 0) ? 0 : a_accSize / a_counter);
    result->createChild("Timeout")->createAttribute("Millisecond", a_timeout.getValue());
    result->createChild("AvgResponseTime")->createAttribute("Millisecond", (a_counter == 0) ? 0 : a_accDelay / a_counter);
    return result;
  }

Here is the call graph for this function:

close()

template<typename Tid >

void anna::timex::Context< Tid >::close ( Transaction *  transaction )

inline

Termina la transación antes de que termine su periodo de espera.

Parameters

transaction

Transación a terminar. Si fuera NULL este método no tiene ningún efecto.

  {
    if(transaction == NULL)
      return;

    LOGINFORMATION(
      std::string msg("timex::Context::close | ");
      msg += transaction->asString();
      Logger::information(msg, ANNA_FILE_LOCATION);
    );

    try {
      a_timeController.cancel(transaction);
    } catch(RuntimeException& ex) {
      ex.trace();
    }
  }

Here is the call graph for this function:

contextAsIdentifier()

template<typename Tid >

virtual const Tid& anna::timex::Context< Tid >::contextAsIdentifier ( const void *  tid ) const

protectedpure virtual

Método virtual puro que debe devolver la clave de aplicación asociada a una transación

Parameters

tid	Puntero que apunta a la clave de aplicación usada para acceder a una transacción.

Returns

La clave de aplicación correspondiente al puntero recibido como parámetro.

createTransaction()

template<typename Tid >

virtual Transaction* anna::timex::Context< Tid >::createTransaction ( const int  classType )

protectedpure virtual

Método virtual puro que creará las transaciones de este contexto cuando sea necesario. Lo más adecuado sería implementar este método mediate el uso del patrón anna::Recycler.

Parameters

classType

Tipo de transación que deseamos crear. Este parámetro sólo será útil en caso de que nuestra aplicación tenga que gestionar varios tipos de transaciones u operaciones.

Returns

Una nueva transación que puede ser usada por este contexto.

find()

template<typename Tid >

Transaction* anna::timex::Context< Tid >::find ( const Tid &  tid, const Exception::Mode::_v  emode = Exception::Mode::Throw  )

inlinenoexcept

Devuelve al instancia de la transación correspondiente al identificador recibido como parámetro.

Parameters

tid	Identificador de aplicación de la transación.
emode	Modo de actuar en caso de que no se encuentre la transacción correspondiente al identificador.

Returns

La transación correspondiente al identificador recibido. Puede ser NULL.

                  {
    Guard guard(a_mutex, "timex::Context::find");
    transaction_iterator ii = a_transactions.find(tid);
    Transaction* result = (ii != a_transactions.end()) ? transaction(ii) : NULL;

    if(result == NULL) {
      if(emode == Exception::Mode::Throw) {
        std::string msg("Transaction: ");
        msg += identifierAsString(tid);
        msg += " | Tid not found";
        throw RuntimeException(msg, ANNA_FILE_LOCATION);
      } else if(emode == Exception::Mode::Trace && Logger::isActive(Logger::Warning)) {
        std::string msg("Transaction: ");
        msg += identifierAsString(tid);
        msg += " | Tid not found";
        Logger::warning(msg, ANNA_FILE_LOCATION);
      }
    }

    return result;
  }

Here is the call graph for this function:

getIdentifier()

template<typename Tid >

const Tid& anna::timex::Context< Tid >::getIdentifier ( const Transaction *  transaction ) const

inlinenoexcept

Obtiene el identificador de aplicación asociado a la transación recibida como parámetro.

Parameters

transaction

Puntero a la transación a procesar. Debe haber sido creada con el método open.

Returns

El identificador de aplicación indicado en el método open.

                  {
    if(transaction == NULL)
      throw RuntimeException("timex::Context::getIdentifier | Can not work with NULL transaction", ANNA_FILE_LOCATION);

    const void* context =  transaction->getContext();

    if(context == NULL) {
      std::string msg("timex::Context::getIdentifier | ");
      msg += transaction->asString();
      msg += " | Can not work with NULL context";
      throw RuntimeException(msg, ANNA_FILE_LOCATION);
    }

    return contextAsIdentifier(context);
  }

Here is the call graph for this function:

getInstance()

template<typename Tid >

static const Context* anna::timex::Context< Tid >::getInstance ( const Transaction *  transaction )

inlinestaticnoexcept

Obtiene la instancia del gestor del contexto asociado a la transación recibida como parámetro. Puede ser NULL.

Parameters

transaction

Puntero a la transación a procesar. Si no ha sido creada con el método open el resultado de esta operación no está determinado.

Returns

la instancia del gestor del contexto asociado a la transación recibida como parámetro. Puede ser NULL.

                  {
    if(transaction == NULL)
      throw RuntimeException("timex::Context::getInstance | Can not work with NULL transaction", ANNA_FILE_LOCATION);

    return reinterpret_cast <const Context*>(transaction->getObserver());
  }

Here is the call graph for this function:

identifierAsString()

template<typename Tid >

virtual std::string anna::timex::Context< Tid >::identifierAsString ( const Tid &  tid ) const

protectedpure virtual

Método virtual puro que debe devolver una std::string correspondiente al valor del identificador recibido como parámetro.

Parameters

tid	Identificador único que la transación.

Returns

una std::string correspondiente al valor del identificador recibido como parámetro.

open()

template<typename Tid >

Transaction* anna::timex::Context< Tid >::open ( const Tid &  tid, const int  classType = 0  )

inlinenoexcept

Crea una transacción con el identificador recibido como parámetro. En caso de que el identificador ya esté registrado en el contexto obtendremos una excepción.

Parameters

tid	Identificador de aplicación de la transación.
classType	Tipo de transación que deseamos crear. Este parámetro sólo será útil en caso de que nuestra aplicación tenga que gestionar varios tipos de transaciones u operaciones.

Este método terminará llamando al método createTransaction.

Returns

La nueva transación que ya habrá sido activada.

                  {
    Transaction* result = NULL;
    {
      Guard guard(a_mutex, "timex::Context::open");
      transaction_iterator ii = a_transactions.find(tid);

      if(ii != a_transactions.end()) {
        std::string msg(transaction(ii)->asString());
        msg += " | Already in progress";
        throw RuntimeException(msg, ANNA_FILE_LOCATION);
      }

      if((result = createTransaction(classType)) == NULL) {
        std::string msg("timex::Context::createTransaction returned NULL | ClassType: ");
        msg += functions::asString(classType);
        throw RuntimeException(msg, ANNA_FILE_LOCATION);
      }

      result->setTimeout(a_timeout);
      result->setObserver(this);
      result->setControlPoint();
      result->setId(anna_ptrnumber_cast(result));
      // Copia en el contexto de la transacción la clave usada.
      // Se usará para poder buscar por clave a la hora de liberar la transacción.
      std::pair <transaction_iterator, bool> rr = a_transactions.insert(value_type(tid, result));
      result->setContext((void*) &rr.first->first);
    }

    try {
      a_timeController.activate(result);
    } catch(RuntimeException&) {
      releaseTransaction(result);
      throw;
    }

    LOGINFORMATION(
      std::string msg("timex::Context::open | ");
      msg += result->asString();
      Logger::information(msg, ANNA_FILE_LOCATION);
    );
    return result;
  }

Here is the call graph for this function:

releaseTransaction()

template<typename Tid >

virtual void anna::timex::Context< Tid >::releaseTransaction ( Transaction *  transaction )

protectedpure virtual

Método virtual puro que liberá el espacio asociado a la transación recibida como parámetro. Lo más adecuado sería implementar este método mediate el uso del patrón anna::Recycler.

Parameters

transaction

Transación a liberar.

---

The documentation for this class was generated from the following file:

• /tmp/anna/include/anna/timex/Context.hpp