TestDiameterCondition.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_testing_TestDiameterCondition_hpp
#define anna_testing_TestDiameterCondition_hpp

// Standard
#include <string>

// Project
#include <anna/core/DataBlock.hpp>


namespace anna {
  namespace xml {
    class Node;
  }

namespace testing {

// TODO: fix types (code to int, etc.)
class TestDiameterCondition {

  public:

    // RegexpXml = Regexp against XML representation for incoming messages
    // RegexpHex = Regexp against HEX representation for incoming messages
    // Fields = Compare specific message fields
    struct Type { enum _v { RegexpXml, RegexpHex, Fields }; };
    static const char* asText(const Type::_v type) ;

    TestDiameterCondition() : a_rcvFromEntity(true),

                      a_regexp(""),

                      a_code(""), a_bitR(""), a_hopByHop(""), a_applicationId(""),
                      a_sessionId(""), a_resultCode(""),
                      a_msisdn(""), a_imsi(""), a_serviceContextId("") { a_type = Type::Fields; }


    // Source of the received message
    void setReceivedFromEntity(bool rfe) { a_rcvFromEntity = rfe; }
    bool receivedFromEntity() const { return a_rcvFromEntity; }

    // Regexp
    void setRegexpXml(const std::string &regexp) { a_regexp = regexp; a_type = Type::RegexpXml; }
    void setRegexpHex(const std::string &regexp) { a_regexp = regexp; a_type = Type::RegexpHex; }

    // Fields
    void setCode(const std::string &value) { a_code = value; a_type = Type::Fields; }
    void setBitR(const std::string &value) { a_bitR = value; a_type = Type::Fields; }
    void setHopByHop(const std::string &value) { a_hopByHop = value; a_type = Type::Fields; }
    void setApplicationId(const std::string &value) { a_applicationId = value; a_type = Type::Fields; }
    void setSessionId(const std::string &value) { a_sessionId = value; a_type = Type::Fields; }
    void setResultCode(const std::string &value) { a_resultCode = value; a_type = Type::Fields; }
    void setMsisdn(const std::string &value) { a_msisdn = value; a_type = Type::Fields; }
    void setImsi(const std::string &value) { a_imsi = value; a_type = Type::Fields; }
    void setServiceContextId(const std::string &value) { a_serviceContextId = value; a_type = Type::Fields; }

    bool exists() const ;
    friend bool operator==(const TestDiameterCondition &c1, const TestDiameterCondition &c2) {

      if (c1.getType() != c2.getType()) return false;

      if (c1.getType() == TestDiameterCondition::Type::RegexpXml || c1.getType() == TestDiameterCondition::Type::RegexpHex) {
        if (c1.getRegexp() != c2.getRegexp()) return false;
      }
      else {
        if (c1.getCode() != c2.getCode()) return false;
        if (c1.getBitR() != c2.getBitR()) return false;
        if (c1.getHopByHop() != c2.getHopByHop()) return false;
        if (c1.getApplicationId() != c2.getApplicationId()) return false;
        if (c1.getSessionId() != c2.getSessionId()) return false;
        if (c1.getResultCode() != c2.getResultCode()) return false;
        if (c1.getMsisdn() != c2.getMsisdn()) return false;
        if (c1.getImsi() != c2.getImsi()) return false;
        if (c1.getServiceContextId() != c2.getServiceContextId()) return false;
      }

      return true;
    }


    const Type::_v &getType() const { return a_type; }

    // Regexp:
    const std::string & getRegexp() const { return a_regexp; }
    // Basic
    const std::string & getCode() const { return a_code; }
    const std::string & getBitR() const { return a_bitR; }
    const std::string & getHopByHop() const { return a_hopByHop; }
    const std::string & getApplicationId() const { return a_applicationId; }
    const std::string & getSessionId() const { return a_sessionId; }
    const std::string & getResultCode() const { return a_resultCode; }
    const std::string & getMsisdn() const { return a_msisdn; }
    const std::string & getImsi() const { return a_imsi; }
    const std::string & getServiceContextId() const { return a_serviceContextId; }


    bool comply (const anna::DataBlock &message) const ;

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


  private:

    // Source of the received message
    bool a_rcvFromEntity;

    // Type
    Type::_v a_type;

    // Generic:
    std::string a_regexp;

    // Basic:
    std::string a_code;
    std::string a_bitR;
    std::string a_hopByHop;
    std::string a_applicationId;
    std::string a_sessionId;
    std::string a_resultCode;
    std::string a_msisdn;
    std::string a_imsi;
    std::string a_serviceContextId;
};

}
}

#endif