EngineImpl.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_EngineImpl_hpp
#define anna_diameter_codec_EngineImpl_hpp


// STL
#include <string>

#include <anna/core/RuntimeException.hpp>
#include <anna/xml/DTDMemory.hpp>
#include <anna/core/util/Recycler.hpp>

#include <anna/core/util/Component.hpp>
#include <anna/diameter/defines.hpp>


//------------------------------------------------------------------------------
//---------------------------------------------------------------------- #define
//------------------------------------------------------------------------------


namespace anna {

namespace diameter {

namespace stack {
class Dictionary;
}

namespace codec {

class Message;
class Avp;


class EngineImpl : public anna::Component {

public:

  struct ValidationDepth { enum _v { Complete, FirstError /* default */ }; };

  struct ValidationMode { enum _v { BeforeEncoding, AfterDecoding /* default */, Always, Never /* optimization */ }; };

  struct FixMode { enum _v { BeforeEncoding /* default */, AfterDecoding, Always, Never /* optimization */ }; };


  // Creators
  Avp* createAvp(const AvpId *id) noexcept(false);
  Message* createMessage(const CommandId *id) noexcept(false);


private:

  ValidationDepth::_v a_validationDepth;
  ValidationMode::_v a_validationMode;
  bool a_singleFailedAVP;
  bool a_ignoreFlags;
  FixMode::_v a_fixMode;

  // Auxiliary
  const stack::Dictionary * a_dictionary;

  // helpers
  static const char* asText(const ValidationDepth::_v) ;
  static const char* asText(const ValidationMode::_v) ;
  static const char* asText(const FixMode::_v) ;

public:

  EngineImpl(const char* className, const stack::Dictionary * dictionary);

  virtual ~EngineImpl() {;}


  const stack::Dictionary *getDictionary() const { return a_dictionary; }


  void setValidationDepth(const ValidationDepth::_v validationDepth)  { a_validationDepth = validationDepth; }

  ValidationDepth::_v getValidationDepth() const { return a_validationDepth; }

  void ignoreFlagsOnValidation(bool ignoreFlags) { a_ignoreFlags = ignoreFlags; }

  bool ignoreFlagsOnValidation() const { return a_ignoreFlags; }

  void setValidationMode(const ValidationMode::_v validationMode)  { a_validationMode = validationMode; }

  ValidationMode::_v getValidationMode() const { return a_validationMode; }



  void setFixMode(const FixMode::_v fixMode)  { a_fixMode = fixMode; }

  FixMode::_v getFixMode() const { return a_fixMode; }

  void setSingleFailedAVP(bool single = true)  { a_singleFailedAVP = single; }

  bool getSingleFailedAVP() const { return a_singleFailedAVP; }

  Avp* createAvp(AvpId id) noexcept(false) { return createAvp(&id); }

  Avp* createAvp() noexcept(false) { return createAvp(NULL); }

  Message* createMessage(CommandId id) noexcept(false) { return createMessage(&id); }

  Message* createMessage() noexcept(false) { return createMessage(NULL); }


  Message *createMessage(const std::string & xmlPathFile_or_string, bool pathfile_or_string = true) noexcept(false);


  virtual void releaseAvp(Avp*)  = 0;

  virtual void releaseMessage(Message*)  = 0;


  virtual std::string asString(void) const ;

  virtual anna::xml::Node* asXML(anna::xml::Node* parent) const ;


  AvpId avpIdForName(const char * name) noexcept(false);


  CommandId commandIdForName(const char * name) noexcept(false);


protected:

  virtual Avp* allocateAvp()  = 0;


  virtual Message* allocateMessage()  = 0;


  void validationAnomaly(const std::string & description) const noexcept(false);
};

}
}
}

#endif