Commit 64d803bd authored by garciay's avatar garciay
Browse files

UpperTester changes validation

parent 2c34c532

ccsrc/EncDec/LibItsDenm_Encdec.cc

+51 −1
Original line number Diff line number Diff line
@@ -119,9 +119,59 @@ namespace LibItsDenm__EncdecDeclarations { 
    

    UpperTesterDenmCodec codec;

    OCTETSTRING os;

    codec.encode(p_utDenmChangePseudonym, os);

    codec.encode((const Record_Type &)p_utDenmChangePseudonym, os);

    return oct2bit(os);

  }



  BITSTRING fx__enc__UtDenmTrigger (const LibItsDenm__TypesAndValues::UtDenmTrigger& p_utDenmTrigger)

  {

    loggers::get_instance().log_msg(">>> fx__enc__UtDenmTrigger: ", p_utDenmTrigger);

    

    UpperTesterDenmCodec codec;

    OCTETSTRING os;

    codec.encode(p_utDenmTrigger, os);

    return oct2bit(os);

  }



  BITSTRING fx__enc__UtDenmUpdate (const LibItsDenm__TypesAndValues::UtDenmUpdate& p_utDenmUpdate)

  {

    loggers::get_instance().log_msg(">>> fx__enc__UtDenmUpdate: ", p_utDenmUpdate);

    

    UpperTesterDenmCodec codec;

    OCTETSTRING os;

    codec.encode(p_utDenmUpdate, os);

    return oct2bit(os);

  }



  BITSTRING fx__enc__UtDenmTermination (const LibItsDenm__TypesAndValues::UtDenmTermination& p_utDenmTermination)

  {

    loggers::get_instance().log_msg(">>> fx__enc__UtDenmTermination: ", p_utDenmTermination);

    

    UpperTesterDenmCodec codec;

    OCTETSTRING os;

    codec.encode(p_utDenmTermination, os);

    return oct2bit(os);

  }



  /****************************************************

   * @desc    External function to decode a UtDenmResults type

   * @param   value to encode

   * @return  encoded value

   ****************************************************/

  INTEGER fx__dec__UtDenmResults(BITSTRING& b, LibItsDenm__TypesAndValues::UtDenmResults& p)

  {

    loggers::get_instance().log(">>> fx__dec__UtDenmResults");



    UpperTesterDenmCodec codec;

    OCTETSTRING is = bit2oct(b);

    std::unique_ptr<Base_Type> ptr = codec.decode(is);

    if (ptr == nullptr) {

      loggers::get_instance().warning("fx__dec__UtDenmResults: -1 result code was returned");

      return -1;

    }

    p = static_cast<LibItsDenm__TypesAndValues::UtDenmResults&>(*ptr);

    return 0;

  }



} //end namespace

ccsrc/Protocols/UpperTester/UpperTesterDenmCodec.cc

0 → 100644
+263 −0
Original line number Diff line number Diff line 
#include <string>

//#include <typeinfo>



#include "UpperTesterDenmCodec.hh"

#include "loggers.hh"



#include "UpperTesterTypes.hh"



template <typename T_type> class OPTIONAL;

class TTCN_EncDec;



int UpperTesterDenmCodec::encode (const Record_Type& msg, OCTETSTRING& data)

{

  loggers::get_instance().log_msg(">>> UpperTesterDenmCodec::encode: ", (const Record_Type&)msg);

  

  TTCN_EncDec::clear_error();

  TTCN_Buffer encoding_buffer;

  if (std::string(msg.get_descriptor()->name).compare("@LibItsDenm_TypesAndValues.UtDenmInitialize") == 0) {

    encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterDenmCodec::c_utDenmInitialize));

  } else if (std::string(msg.get_descriptor()->name).compare("@LibItsDenm_TypesAndValues.UtDenmChangePosition") == 0) {

    encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterDenmCodec::c_utDenmChangePosition));

  } else if (std::string(msg.get_descriptor()->name).compare("@LibItsDenm_TypesAndValues.UtDenmChangePseudonym") == 0) {

    encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterDenmCodec::c_utDenmChangePseudonym));

  } else if (std::string(msg.get_descriptor()->name).compare("@LibItsDenm_TypesAndValues.UtDenmTrigger") == 0) {

    encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterDenmCodec::c_utDenmTrigger));

    // See ETSI TR 103 099 V1.3.21 (20152016-07) Clause C.4.1GenerateDenmEvent

    unsigned char flags = 0x00;

    const LibItsDenm__TypesAndValues::UtDenmTrigger &r = static_cast<const LibItsDenm__TypesAndValues::UtDenmTrigger &>(msg);

    if (r.validityDuration().is_present()) { // V

      flags |= 0x80;

    }

    if (r.repetitionDuration().is_present()) { // R

      flags |= 0x40;

    }

    if (r.relevanceTrafficDirection().is_present()) { // T

      flags |= 0x10;

    }

    if (r.transmissionInterval().is_present()) { // K

      flags |= 0x04;

    }

    if (r.repetitionInterval().is_present()) { // I

      flags |= 0x02;

    }

    encoding_buffer.put_c(flags);

    // Continue with encoding

  } else if (std::string(msg.get_descriptor()->name).compare("@LibItsDenm_TypesAndValues.UtDenmUpdate") == 0) {

    encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterDenmCodec::c_utDenmUpdate));

    // See ETSI TR 103 099 V1.3.21 (20152016-07) Clause C.4.1GenerateDenmEvent

    unsigned char flags = 0x00;

    const LibItsDenm__TypesAndValues::UtDenmUpdate &r = static_cast<const LibItsDenm__TypesAndValues::UtDenmUpdate &>(msg);

    if (r.validityDuration().is_present()) { // V

      flags |= 0x80;

    }

    if (r.situation().is_present()) { // S

      flags |= 0x40;

    }

    if (r.relevanceDistance().is_present()) { // D

      flags |= 0x20;

    }

    if (r.relevanceTrafficDirection().is_present()) { // T

      flags |= 0x10;

    }

    // TODO Check TTCN-3 code, it's missing

    /*if (r.trafficClass().is_present()) { // C

      flags |= 0x08;

      }*/

    if (r.transmissionInterval().is_present()) { // K

      flags |= 0x04;

    }

    if (r.repetitionInterval().is_present()) { // I

      flags |= 0x02;

    }

    encoding_buffer.put_c(flags);

  } else if (std::string(msg.get_descriptor()->name).compare("@LibItsDenm_TypesAndValues.UtDenmTermination") == 0) {

    encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterDenmCodec::c_utDenmTermination));

  } else { // Error

    data = OCTETSTRING();

    loggers::get_instance().log("<<< UpperTesterDenmCodec::encode: Return -1");

    return -1;

  }

  encode_(msg, *msg.get_descriptor(), encoding_buffer);

  data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());

  loggers::get_instance().log_msg("<<< UpperTesterDenmCodec::encode: data=", data);

  return 0;

}



int UpperTesterDenmCodec::encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& encoding_buffer)

{

  loggers::get_instance().log(">>> UpperTesterDenmCodec::encode_: processing %s/%s/%p", type.get_descriptor()->name, field_descriptor.name, dynamic_cast<const Record_Type*>(&type));

  loggers::get_instance().log_msg(">>> UpperTesterDenmCodec::encode_: ", type);

  

  if (dynamic_cast<const Record_Type*>(&type) != NULL) {

    const Record_Type& r = (const Record_Type &)type;

    loggers::get_instance().log("UpperTesterDenmCodec::encode_: processing Record_Type %s", r.get_descriptor()->name);

    for(int i = 0; i < r.get_count(); i++) {

      loggers::get_instance().log("UpperTesterDenmCodec::encode_: processing %s/%s/%s - %d (1 ==> use dynamic_cast<const OPTIONAL<...>) - %d", r.fld_name(i), r.fld_descr(i)->name, r.get_at(i)->get_descriptor()->name, r.get_at(i)->is_optional(), r.get_at(i)->is_present());

      if (r.get_at(i)->is_present()) {

        if (encode_(*r.get_at(i), *r.fld_descr(i), encoding_buffer) == -1) {

          loggers::get_instance().warning("UpperTesterDenmCodec::encode_: -1 result code returned");

          return -1;

        }

      } else if (std::string(r.fld_name(i)).compare("alacarte") == 0) {

        // Add empty field length

        loggers::get_instance().log("UpperTesterDenmCodec::encode_: alacarte is missing, add 0x00");

        encoding_buffer.put_c(0x00);

      }

    } // End of 'for' statement

  } else {

    std::string s(field_descriptor.name);

    loggers::get_instance().log("UpperTesterDenmCodec::encode_: field to process %s", s.c_str());

    if (

        (s.rfind(".shape") != string::npos) ||

        (s.rfind(".relevanceDistance") != string::npos) ||

        (s.rfind(".relevanceTrafficDirection") != string::npos)

        ) {

      encoding_buffer.put_c((unsigned char)static_cast<const Enum_Type&>(type).as_int());

    } else if (s.rfind(".payload") != string::npos) {

      const OCTETSTRING& os = static_cast<const OCTETSTRING&>(type);

      const unsigned char s[] = { (unsigned char)((os.lengthof() & 0x0000FF00) >> 8), (unsigned char)os.lengthof() };

      encoding_buffer.put_s(2, s);

      if (os.lengthof() != 0) {

        encoding_buffer.put_string(os);

      }

    } else if (s.rfind(".detectionTime") != string::npos) {

      unsigned long long llu = static_cast<const INTEGER&>(type).get_long_long_val();

      loggers::get_instance().log("UpperTesterDenmCodec::encode_ : detectionTime=%llu", llu);

      std::vector<unsigned char> v;

      for (int i = 0; i < 6; i++) {

        v.insert(v.begin(), static_cast<unsigned char>(llu));

        llu >>= 8;

      } // End of 'for' statement

      OCTETSTRING os(v.size(), v.data());

      loggers::get_instance().log_msg("UpperTesterDenmCodec::encode_: timeDetection=", os);

      encoding_buffer.put_string(os);

    } else if (

               (s.rfind(".validityDuration") != string::npos) ||

               (s.rfind(".repetitionDuration") != string::npos)

               ) {

      if (type.is_present()) {

        const OPTIONAL<INTEGER> &o = dynamic_cast<const OPTIONAL<INTEGER> &>(type);

        const INTEGER& i = static_cast<const INTEGER&>(*o.get_opt_value());

        loggers::get_instance().log_msg("UpperTesterDenmCodec::encode_: i=", i);

        encoding_buffer.put_string(int2oct(i, 3));

      }

    } else if (

               (s.rfind(".informationQuality") != string::npos) ||

               (s.rfind(".causeCode") != string::npos) ||

               (s.rfind(".subCauseCode") != string::npos)

               ) {

      const INTEGER& i = static_cast<const INTEGER&>(type);

      encoding_buffer.put_string(int2oct(i, 1));

    } else if (

               (s.rfind(".linkedCause") != string::npos) ||

               (s.rfind(".eventHistory") != string::npos)

               ) {

      // Skip them

    } else if (

               (s.rfind(".transmissionInterval") != string::npos) ||

               (s.rfind(".repetitionInterval") != string::npos)

               ) {

      if (type.is_present()) {

        const OPTIONAL<INTEGER> &o = dynamic_cast<const OPTIONAL<INTEGER> &>(type);

        const INTEGER& i = static_cast<const INTEGER&>(*o.get_opt_value());

        encoding_buffer.put_string(int2oct(i, 2));

      }

    } else if (s.rfind(".originatingStationID") != string::npos) {

      const INTEGER& i = static_cast<const INTEGER&>(type);

      encoding_buffer.put_string(int2oct(i, 4));

    } else if (s.rfind(".sequenceNumber") != string::npos) {

      const INTEGER& i = static_cast<const INTEGER&>(type);

      encoding_buffer.put_string(int2oct(i, 2));

    } else if (s.rfind(".situation") != string::npos) {

      const OPTIONAL<DENM__PDU__Descriptions::SituationContainer> &o = dynamic_cast<const OPTIONAL<DENM__PDU__Descriptions::SituationContainer> &>(type);

      const DENM__PDU__Descriptions::SituationContainer& bt = static_cast<const DENM__PDU__Descriptions::SituationContainer&>(*o.get_opt_value());

      encode_(bt, field_descriptor, encoding_buffer);

    } else if (s.rfind(".AlacarteContainer") != string::npos) {

      const OPTIONAL<OCTETSTRING> &o = dynamic_cast<const OPTIONAL<OCTETSTRING> &>(type);

      const OCTETSTRING& os = static_cast<const OCTETSTRING&>(*o.get_opt_value());

      encoding_buffer.put_string(int2oct(os.lengthof(), 2));

      encoding_buffer.put_string(os);

    } else {

      loggers::get_instance().log("UpperTesterDenmCodec::encode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);

      type.encode(field_descriptor, encoding_buffer, TTCN_EncDec::CT_RAW);

    }

  }

  

  loggers::get_instance().log_to_hexa("<<<UpperTesterDenmCodec::encode_: encoding_buffer=", encoding_buffer);

  return 0;

}



int UpperTesterDenmCodec::decode (const OCTETSTRING& data, Record_Type& msg, Params* params)

{

  TTCN_EncDec::clear_error();

  TTCN_Buffer decoding_buffer(data);

  _params = params;

  

  loggers::get_instance().log_to_hexa(">>> UpperTesterDenmCodec::decode: decoding_buffer=", decoding_buffer);

  //decode_(msg, *msg.get_descriptor(), decoding_buffer);

  

  loggers::get_instance().log_msg("<<< UpperTesterDenmCodec::decode: ", (const Record_Type&)msg);

  return 0;

}



std::unique_ptr<Base_Type> UpperTesterDenmCodec::decode (const OCTETSTRING& data, Params* params) {



  std::unique_ptr<Base_Type> result;

  

  const unsigned char* ptr = static_cast<const unsigned char*>(data);

  if (*ptr != UpperTesterDenmCodec::c_utDenmEventInd) {

    LibItsDenm__TypesAndValues::UtDenmResults res;

    decode(data, res, params);

    result.reset((Base_Type *)res.clone());

  } else {

    LibItsDenm__TypesAndValues::UtDenmEventInd ind;

    decode(data, ind, params);

    result.reset((Base_Type *)ind.clone());

  }



  return result;

}



int UpperTesterDenmCodec::decode (const OCTETSTRING& data, LibItsDenm__TypesAndValues::UtDenmResults& msg, Params* params)

{

  loggers::get_instance().log_to_hexa(">>> UpperTesterDenmCodec::decode: decoding_buffer=", data);



  const unsigned char* ptr = static_cast<const unsigned char*>(data);

  if (*ptr == UpperTesterDenmCodec::c_utDenmInitializeResult) {

    msg.utDenmInitializeResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else if (*ptr == UpperTesterDenmCodec::c_utDenmChangePositionResult) {

    msg.utDenmChangePositionResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else if (*ptr == UpperTesterDenmCodec::c_utDenmChangePseudonymResult) {

    msg.utDenmChangePseudonymResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else if (*ptr == UpperTesterDenmCodec::c_utDenmTerminationResult) {

    msg.utDenmTerminationResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else if (*ptr == UpperTesterDenmCodec::c_utDenmTriggerResult) {

    LibItsDenm__TypesAndValues::UtDenmTriggerResult r;

    ptr += 1;

    r.result() = BOOLEAN(*ptr == 0x01);

    ptr += 1;

    OCTETSTRING os(4, ptr);

    ptr += 4;

    r.actionId().originatingStationID() = oct2int(os);

    os  = OCTETSTRING(2, ptr);

    r.actionId().sequenceNumber() = oct2int(os);

    msg.utDenmTriggerResult() = r;

  } else if (*ptr == UpperTesterDenmCodec::c_utDenmUpdateResult) {

    LibItsDenm__TypesAndValues::UtDenmUpdateResult r;

    ptr += 1;

    r.result() = BOOLEAN(*ptr == 0x01);

    ptr += 1;

    OCTETSTRING os(4, ptr);

    ptr += 4;

    r.actionId().originatingStationID() = oct2int(os);

    os  = OCTETSTRING(2, ptr);

    r.actionId().sequenceNumber() = oct2int(os);

    msg.utDenmUpdateResult() = r;

  } else {

    TTCN_warning("UpperTesterDenmCodec::decode: Unsupported result");

  }

  

  loggers::get_instance().log_msg("<<< UpperTesterDenmCodec::decode", msg);

  return 0;

}

ccsrc/Protocols/UpperTester/UpperTesterDenmCodec.hh

0 → 100644
+48 −0
Original line number Diff line number Diff line 
#ifndef UpperTesterDenmCODEC_H

#define UpperTesterDenmCODEC_H



#include "Codec.hh"

#include "loggers.hh" // TODO To be removed

#include "Params.hh"



class Base_Type;

class Record_Type;

class TTCN_Typedescriptor_t;

class TTCN_Buffer;



namespace LibItsDenm__TypesAndValues {

  class UtDenmResults;

}



class UpperTesterDenmCodec: public Codec <

  Record_Type,

  Record_Type>

{

  const unsigned char c_utDenmInitialize = 0x00;

  const unsigned char c_utDenmInitializeResult = 0x01;

  const unsigned char c_utDenmChangePosition = 0x02;

  const unsigned char c_utDenmChangePositionResult = 0x03;

  const unsigned char c_utDenmChangePseudonym = 0x04;

  const unsigned char c_utDenmChangePseudonymResult = 0x05;

  const unsigned char c_utDenmTrigger = 0x10;

  const unsigned char c_utDenmTriggerResult = 0x11;

  const unsigned char c_utDenmUpdate = 0x12;

  const unsigned char c_utDenmUpdateResult = 0x13;

  const unsigned char c_utDenmTermination = 0x14;

  const unsigned char c_utDenmTerminationResult = 0x15;

  const unsigned char c_utDenmEventInd = 0x17;



  int encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& encoding_buffer);



public:

  UpperTesterDenmCodec() : Codec<Record_Type, Record_Type>() { loggers::get_instance().log("UpperTesterDenmCodec::UpperTesterDenmCodec(D)"); };

  virtual ~UpperTesterDenmCodec() { loggers::get_instance().log("UpperTesterDenmCodec::~UpperTesterDenmCodec"); };



  virtual int encode (const Record_Type&, OCTETSTRING& data);

  virtual int decode (const OCTETSTRING& data, Record_Type&, Params* params = NULL);

  virtual std::unique_ptr<Base_Type> decode (const OCTETSTRING& data, Params* params = NULL);

  

private:

  int decode (const OCTETSTRING& data, LibItsDenm__TypesAndValues::UtDenmResults& msg, Params* params = NULL);

};

#endif

ccsrc/Protocols/UpperTester/UpperTesterGnCodec.cc

0 → 100644
+181 −0
Original line number Diff line number Diff line 
#include <string>

//#include <typeinfo>



#include "UpperTesterGnCodec.hh"

#include "loggers.hh"



#include "UpperTesterTypes.hh"



template <typename T_type> class OPTIONAL;

class TTCN_EncDec;



int UpperTesterGnCodec::encode (const Record_Type& msg, OCTETSTRING& data)

{

  loggers::get_instance().log_msg(">>> UpperTesterGnCodec::encode: ", (const Record_Type&)msg);

  

  TTCN_EncDec::clear_error();

  TTCN_Buffer encoding_buffer;

  if (std::string(msg.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.UtGnInitialize") == 0) {

    encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterGnCodec::c_utGnInitialize));

  } else if (std::string(msg.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.UtGnChangePosition") == 0) {

    encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterGnCodec::c_utGnChangePosition));

  } else { // Error

    data = OCTETSTRING();

    return -1;

  }

  encode_(msg, *msg.get_descriptor(), encoding_buffer);

  data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());



  loggers::get_instance().log_msg("<<< UpperTesterGnCodec::encode: data=", data);

  return 0;

}



int UpperTesterGnCodec::encode (const Base_Type& msg, OCTETSTRING& data)

{

  loggers::get_instance().log(">>> UpperTesterGnCodec::encode: %s", msg.get_descriptor()->name);

  

  TTCN_EncDec::clear_error();

  TTCN_Buffer encoding_buffer;



  Base_Type* type = nullptr;

  if (std::string(msg.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.UtGnTrigger") == 0) {

    const LibItsGeoNetworking__TypesAndValues::UtGnTrigger& t = static_cast<const LibItsGeoNetworking__TypesAndValues::UtGnTrigger&>(msg);

    loggers::get_instance().log("UpperTesterGnCodec::encode: After cast: %s", t.get_descriptor()->name); 

    if (t.ischosen(LibItsGeoNetworking__TypesAndValues::UtGnTrigger::ALT_geoUnicast)) {

      encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterGnCodec::c_utGnTrigger_GeoUnicast));

      type = (Base_Type*)&(t.geoUnicast());

    } else if (t.ischosen(LibItsGeoNetworking__TypesAndValues::UtGnTrigger::ALT_geoBroadcast)) {

      encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterGnCodec::c_utGnTrigger_GeoBroadcast));

      type = (Base_Type*)&(t.geoBroadcast());

    } else if (t.ischosen(LibItsGeoNetworking__TypesAndValues::UtGnTrigger::ALT_geoAnycast)) {

      encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterGnCodec::c_utGnTrigger_GeoAnycast));

      type = (Base_Type*)&(t.geoAnycast());

    } else if (t.ischosen(LibItsGeoNetworking__TypesAndValues::UtGnTrigger::ALT_shb)) {

      encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterGnCodec::c_utGnTrigger_Shb));

      type = (Base_Type*)&(t.shb());

    } else if (t.ischosen(LibItsGeoNetworking__TypesAndValues::UtGnTrigger::ALT_tsb)) {

      encoding_buffer.put_c(static_cast<unsigned char>(UpperTesterGnCodec::c_utGnTrigger_Tsb));

      type = (Base_Type*)&(t.tsb());

    } // else, nothing to do

  } else {

    data = OCTETSTRING();

    return -1;

  }

  encode_(*type, *(type->get_descriptor()), encoding_buffer);

  data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());



  loggers::get_instance().log_msg("<<< UpperTesterGnCodec::encode: data=", data);



  return 0;

}



int UpperTesterGnCodec::encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& encoding_buffer)

{

  loggers::get_instance().log(">>> UpperTesterGnCodec::encode_: processing %s/%s", type.get_descriptor()->name, field_descriptor.name);

  loggers::get_instance().log_msg(">>> UpperTesterGnCodec::encode_: ", type);

  

  if (dynamic_cast<const Record_Type*>(&type) != NULL) {

    const Record_Type& r = (const Record_Type &)type;

    loggers::get_instance().log("UpperTesterGnCodec::encode_: processing Record_Type %s", r.get_descriptor()->name);

    for(int i = 0; i < r.get_count(); i++) {

      loggers::get_instance().log("UpperTesterGnCodec::encode_: processing %s/%s/%s - %d (1 ==> use dynamic_cast<const OPTIONAL<...>) - %d", r.fld_name(i), r.fld_descr(i)->name, r.get_at(i)->get_descriptor()->name, r.get_at(i)->is_optional(), r.get_at(i)->is_present());

      if (r.get_at(i)->is_present()) {

        if (encode_(*r.get_at(i), *r.fld_descr(i), encoding_buffer) == -1) {

          loggers::get_instance().warning("UpperTesterGnCodec::encode_: -1 result code returned");

          return -1;

        }

      }

    } // End of 'for' statement

  } else {

    std::string s(field_descriptor.name);

    if (s.rfind(".shape") != string::npos) {

      encoding_buffer.put_c((unsigned char)static_cast<const Enum_Type&>(type).as_int());

    } else if (s.rfind(".payload") != string::npos) {

      const OCTETSTRING& os = static_cast<const OCTETSTRING&>(type);

      const unsigned char s[] = { (unsigned char)((os.lengthof() & 0x0000FF00) >> 8), (unsigned char)os.lengthof() };

      encoding_buffer.put_s(2, s);

      if (os.lengthof() != 0) {

        encoding_buffer.put_string(os);

      }

    } else {

      loggers::get_instance().log("UpperTesterGnCodec::encode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);

      type.encode(field_descriptor, encoding_buffer, TTCN_EncDec::CT_RAW);

    }

  }

  

  loggers::get_instance().log_to_hexa("<<<UpperTesterGnCodec::encode_: encoding_buffer=", encoding_buffer);

  return 0;

}



int UpperTesterGnCodec::decode (const OCTETSTRING& data, Record_Type& msg, Params* params)

{

  TTCN_EncDec::clear_error();

  TTCN_Buffer decoding_buffer(data);

  _params = params;

  

  loggers::get_instance().log_to_hexa(">>> UpperTesterGnCodec::decode: decoding_buffer=", decoding_buffer);

  //decode_(msg, *msg.get_descriptor(), decoding_buffer);

  

  loggers::get_instance().log_msg("<<< UpperTesterGnCodec::decode: ", (const Record_Type&)msg);

  return 0;

}



std::unique_ptr<Base_Type> UpperTesterGnCodec::decode (const OCTETSTRING& data, Params* params) {



  std::unique_ptr<Base_Type> result;

  

  const unsigned char* ptr = static_cast<const unsigned char*>(data);

  if (

      (*ptr == UpperTesterGnCodec::c_utGnInitializeResult) ||

      (*ptr == UpperTesterGnCodec::c_utGnChangePositionResult) ||

      (*ptr == UpperTesterGnCodec::c_utGnTriggerResult)

      ) {

    LibItsGeoNetworking__TypesAndValues::UtGnResults res;

    decode(data, res, params);

    result.reset((Base_Type *)res.clone());

  } else {

    LibItsGeoNetworking__TypesAndValues::UtGnEventInd ind;

    decode(data, ind, params);

    result.reset((Base_Type *)ind.clone());

  }



  return result;

}



int UpperTesterGnCodec::decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::UtGnResults& msg, Params* params)

{

  loggers::get_instance().log_to_hexa(">>> UpperTesterGnCodec::decode: decoding_buffer=", data);



  const unsigned char* ptr = static_cast<const unsigned char*>(data);

  if (*ptr == UpperTesterGnCodec::c_utGnInitializeResult) {

    msg.utGnInitializeResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else if (*ptr == UpperTesterGnCodec::c_utGnChangePositionResult) {

    msg.utGnChangePositionResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else if (*ptr == UpperTesterGnCodec::c_utGnTriggerResult) {

    msg.utGnTriggerResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else {

    TTCN_warning("UpperTesterGnCodec::decode: Unsupported result");

  }

  

  loggers::get_instance().log_msg("<<< UpperTesterGnCodec::decode", msg);

  return 0;

}



int UpperTesterGnCodec::decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::UtGnEventInd& msg, Params* params)

{

  loggers::get_instance().log_to_hexa(">>> UpperTesterGnCodec::decode: decoding_buffer=", data);



  /*const unsigned char* ptr = static_cast<const unsigned char*>(data);

  if (*ptr == UpperTesterGnCodec::c_utDenmInitializeResult) {

    msg.utDenmInitializeResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else if (*ptr == UpperTesterGnCodec::c_utChangePositionResult) {

    msg.utChangePseudonymResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else if (*ptr == UpperTesterGnCodec::c_utDenmTriggerResult) {

    // TODO msg.utDenmTriggerResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else {

    TTCN_warning("UpperTesterGnCodec::decode: Unsupported result");

    }*/

  

  loggers::get_instance().log_msg("<<< UpperTesterGnCodec::decode", msg);

  return 0;

}

ccsrc/Protocols/UpperTester/UpperTesterGnCodec.hh

0 → 100644
+48 −0

File added.

Preview size limit exceeded, changes collapsed.

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.cc

+31 −31

File changed.

Contains only whitespace changes.