OamModule.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_diameter_codec_OamModule_hpp
#define anna_diameter_codec_OamModule_hpp


// Project
#include <anna/core/Singleton.hpp>
#include <anna/core/define.autoenum.hpp>
#include <anna/core/oam/Module.hpp>

// Standard
#include <string>


namespace anna {

namespace diameter {

namespace codec {


class OamModule : public anna::oam::Module, public anna::Singleton <OamModule> {

public:

  struct Alarm {

    // Transferable Alarms:    preffix = c_                                                                     //
    // Grouped Alarms:         preffix = g_                                                                     //
    //                         Be careful: this alarms take more than one place (better define them at the end) //

    enum _v {

      None = -1,

      // All defined alarms are not transferable //

      /* Avp decoding */

      AvpDecode__NotEnoughBytesToCoverAvpHeaderLength,
      // El buffer pasado no es suficiente para construir un AVP
      // Not enough buffer to build AVP

      AvpDecode__IncoherenceBetweenActivatedVBitAndZeroedVendorIDValueReceived,
      // Los Flags indican que el AVP es vendor-specific (bit V) y sin embargo el campo vendor-ID tiene un valor 0 (IETF)
      // AVP Flags are vendor-specific (V bit) but vendor-ID octets value is 0 (IETF)

      AvpDecode__IncorrectLength,
      // Existe un error de formato en el AVP, la longitud es incorrecta
      // There is an error inside the AVP, the length is not correct

      AvpDecode__DataPartInconsistence,
      // Existe un error de inconsistencia en la parte de datos
      // There is an inconsistence error inside the AVP data part

      AvpDecode__UnknownAvp__s__WithMandatoryBit,
      // Formato desconocido del AVP %s con bit M activo
      // Unknown format for AVP %s with activated M bit

      /* Message decoding */

      MessageDecode__NotEnoughBytesToCoverMessageHeaderLength,
      // El buffer pasado no es suficiente para construir la cabecera de un mensaje DIAMETER
      // Not enough buffer to build the DIAMETER message header

      MessageDecode__NotEnoughBytesToCoverMessageLength,
      // No se han proporcionado octetos suficientes para cubrir la longitud del mensaje DIAMETER
      // Not enough bytes to fit DIAMETER message length


      /* Avp validation */

      AvpValidation__EnumeratedAvp__s__WithValue__d__DoesNotComplyRestriction__s__,
      // El AVP enumerado %s con valor %d, no cumple la restriccion: %s
      // Enumerated AVP %s with value %d does not comply to restriction: %s

      AvpValidation__Avp__s__Flags__d__DoesNotFulfillTheDefinedFlagRules__s__,
      // El AVP %s tiene flags (%d) incoherentes con las reglas de flags definidas: %s
      // AVP %s flags (%d) does not fulfill the defined flag rules: %s


      /* Message validation */

      MessageValidation__UnknownOperation__s__UnableToValidate,
      // Operacion %s desconocida, imposible validar
      // Unknown operation %s, unable to validate

      MessageValidation__Operation__s__HaveIncoherentFlags__d__,
      // La operacion %s tiene flags (%d) incoherentes
      // Operation %s have incoherent flags (%d)


      /* Level validation */

      LevelValidation__MissingFixedRule__s__Inside__s__,
      // Falta un AVP fijo %s dentro de %s
      // Missing fixed rule %s inside %s

      LevelValidation__FailedRule__s__ForCardinality_Found__d__ItemsInside__s__,
      // Ha fallado la regla %s de cardinalidad (encontrados %s items dentro de %s)
      // Failed rule %s for cardinality (found %d items inside %s)

      LevelValidation__FailedGenericAvpRule__s__ForCardinality_Found__d__DisregardedItemsInside__s__,
      // Ha fallado la regla del AVP Generico %s para la cardinalidad (encontrados %d items no contemplados dentro de %s)
      // Failed Generic AVP rule %s for cardinality (found %d disregarded items inside %s)

      LevelValidation__FoundDisregardedItemsInside__s__AndGenericAVPWasNotSpecified__s__
      // Encontrados items no contemplados dentro de %s y el AVP Generico no se especifico: %s
      // Found disregarded items inside %s and Generic AVP was not specified: %s
    };

    anna_declare_enum(Alarm);
  };

  struct Counter {
    enum _v
    // In order to simplify, the literals assigned to
    //  enum-type counters are equal to specification ones (in spanish)
    {
      None = -1,

      /* Avp decoding */
      AvpDecode__NotEnoughBytesToCoverAvpHeaderLength,
      AvpDecode__IncoherenceBetweenActivatedVBitAndZeroedVendorIDValueReceived,
      AvpDecode__IncorrectLength,
      AvpDecode__DataPartInconsistence,
      AvpDecode__UnknownAvpWithMandatoryBit,

      /* Message decoding */
      MessageDecode__NotEnoughBytesToCoverMessageHeaderLength,
      MessageDecode__NotEnoughBytesToCoverMessageLength,

      /* Avp validation */
      AvpValidation__EnumeratedAvpWithValueDoesNotComplyRestriction,
      AvpValidation__AvpFlagsDoesNotFulfillTheDefinedFlagRules,

      /* Message validation */
      MessageValidation__UnknownOperationUnableToValidate,
      MessageValidation__OperationHaveIncoherentFlags,

      /* Level validation */
      LevelValidation__MissingFixedRule,
      LevelValidation__FailedRuleForCardinality,
      LevelValidation__FailedRuleForCardinalityLessThanNeeded,
      LevelValidation__FailedRuleForCardinalityMoreThanNeeded,
      LevelValidation__FailedGenericAvpRuleForCardinalityFoundDisregardedItem,
      LevelValidation__FoundDisregardedItemsAndGenericAVPWasNotSpecified
    };

    anna_declare_enum(Counter);
  };

  /* virtual */std::string getDefaultInternalAlarmDescription(const int & alarmType) const { return Alarm::asCString((Alarm::_v)alarmType); }
  /* virtual */std::string getDefaultInternalCounterDescription(const int & counterType) const { return Counter::asCString((Counter::_v)counterType); }


private:

  // private constructor
  OamModule() : anna::oam::Module("diameter::codec oam module") {};


  friend class anna::Singleton <OamModule>;
};

}
}
}

#endif