Format.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_stack_Format_hpp
#define anna_diameter_stack_Format_hpp

// Local
#include <anna/diameter/codec/Format.hpp>

#include <anna/config/defines.hpp>
#include <anna/core/RuntimeException.hpp>

// STL
#include <string>



namespace anna {
namespace xml {
class Node;
}
}



namespace anna {

namespace diameter {

namespace stack {

class Dictionary;

//------------------------------------------------------------------------------
//----------------------------------------------------------------- class Format
//------------------------------------------------------------------------------
class Format {
  const Dictionary *a_dictionary;
  std::string a_name;
  std::string a_parentName;

  void _initialize(const Dictionary *d) {
    a_dictionary = d;
    a_name = "";
    a_parentName = "";
  }

public:

  Format(const Dictionary *d = NULL) { _initialize(d); }
  ~Format() {};


  // get

  const std::string & getName(void) const { return a_name; }

  const std::string & getParentName(void) const { return a_parentName; }

  // helpers

  const Format * getParent(void) const ;

  bool isDerived(void) const { return (a_parentName != ""); }

  bool isBasic(void) const { return (!isDerived() && !isReserved()); }

  codec::Format::_v getBasicType(void) const noexcept(false);

  bool isRFC3588(void) const { return (codec::Format::isRFC3588(a_name)); }

  // Reserved
  bool isAny() const { return (a_name == codec::Format::asText(codec::Format::Any)); }
//   /** @return The format is 'Unknown' */
//   bool isUnknown() const { return (a_name == codec::Format::asText(codec::Format::Unknown)); }

  // RFC 3588
  bool isOctetString() const { return (a_name == codec::Format::asText(codec::Format::OctetString)); }
  bool isInteger32() const { return (a_name == codec::Format::asText(codec::Format::Integer32)); }
  bool isInteger64() const { return (a_name == codec::Format::asText(codec::Format::Integer64)); }
  bool isUnsigned32() const { return (a_name == codec::Format::asText(codec::Format::Unsigned32)); }
  bool isUnsigned64() const { return (a_name == codec::Format::asText(codec::Format::Unsigned64)); }
  bool isFloat32() const { return (a_name == codec::Format::asText(codec::Format::Float32)); }
  bool isFloat64() const { return (a_name == codec::Format::asText(codec::Format::Float64)); }
  bool isGrouped() const { return (a_name == codec::Format::asText(codec::Format::Grouped)); }
  bool isAddress() const { return (a_name == codec::Format::asText(codec::Format::Address)); }
  bool isTime() const { return (a_name == codec::Format::asText(codec::Format::Time)); }
  bool isUTF8String() const { return (a_name == codec::Format::asText(codec::Format::UTF8String)); }
  bool isDiameterIdentity() const { return (a_name == codec::Format::asText(codec::Format::DiameterIdentity)); }
  bool isDiameterURI() const { return (a_name == codec::Format::asText(codec::Format::DiameterURI)); }
  bool isEnumerated() const { return (a_name == codec::Format::asText(codec::Format::Enumerated)); }
  bool isIPFilterRule() const { return (a_name == codec::Format::asText(codec::Format::IPFilterRule)); }
  bool isQoSFilterRule() const { return (a_name == codec::Format::asText(codec::Format::QoSFilterRule)); }

  bool isApplicationSpecific(void) const { return (!isRFC3588() && !isReserved()); }

  bool isReserved(void) const { return (codec::Format::isReserved(a_name)); }

  std::string asString(void) const ;

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

  // operators

  friend bool operator == (const Format & f1, const Format & f2) { return ((f1.getName() == f2.getName())); }

  friend bool operator != (const Format & f1, const Format & f2) { return !(f1 == f2); }

  // set

  void initialize(const Dictionary *d = NULL) { _initialize(d); }

  void setName(const char * name) noexcept(false) {
    if(name == NULL) throw anna::RuntimeException("Null Format-name not allowed", ANNA_FILE_LOCATION);

    a_name = name;

    if(a_name == "") throw anna::RuntimeException("Empty Format-name not allowed", ANNA_FILE_LOCATION);
  }

  void setRFC3588(codec::Format::_v rfc3588Format) {
    setName(codec::Format::asText(rfc3588Format));
  }

  void setParentName(const std::string & parentName) noexcept(false);
};


}
}
}


#endif