Commit 8e254c73 authored by garciay's avatar garciay
Browse files

Rebuild project with TITAN/Eclipse

parent 6715e595

ccsrc/EncDec/LibItsMapemSpatem_Encdec.cc

+88 −85

File changed.

Preview size limit exceeded, changes collapsed.

ccsrc/EncDec/LibItsSremSsem_Encdec.cc

+115 −114
Original line number Diff line number Diff line 
#include "LibIts_EncdecDeclarations.hh"

#include "LibItsSremSsem_EncdecDeclarations.hh"



#include "SremSsemCodec.hh"

#include "UpperTesterSremCodec.hh"

#include "SremCodec.hh"

#include "SsemCodec.hh"

#include "UpperTesterSremSsemCodec.hh"

#include "loggers.hh"



namespace LibItsSremSsem__EncdecDeclarations {
@@ -14,7 +15,7 @@ namespace LibItsSremSsem__EncdecDeclarations { 
  {

    loggers::get_instance().log_msg(">>> fx__enc__SremReq: ", p_sremReq);

    

    SremSsemCodec codec;

    SremCodec codec;

    OCTETSTRING os;

    if (codec.encode(p_sremReq.msgOut(), os) == -1) {

      loggers::get_instance().warning("fx__enc__SremReq: -1 result code was returned");
@@ -33,8 +34,8 @@ namespace LibItsSremSsem__EncdecDeclarations { 
  {

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



    SremSsemCodec codec;

    SREM_PDU_Descriptions::SREM srem;

    SremCodec codec;

    SREM__PDU__Descriptions::SREM srem;

    OCTETSTRING is = bit2oct(b);



    if (codec.decode(is, srem) == -1) {
@@ -50,24 +51,24 @@ namespace LibItsSremSsem__EncdecDeclarations { 
  {

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

    

    SremSsemCodec codec;

    SREM_PDU_Descriptions::SREM srem;

    SremCodec codec;

    SREM__PDU__Descriptions::SREM srem;

    OCTETSTRING is = bit2oct(b);



    // Calculate the size of the lower layers information

    int s = (

	     LibItsSremSsem__TestSystem::SremSsemInd_gnNextHeader_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremSsemInd_gnHeaderType_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremSsemInd_gnHeaderSubtype_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremSsemInd_gnLifetime_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremSsemInd_gnTrafficClass_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremSsemInd_btpDestinationPort_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremSsemInd_btpInfo_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremSsemInd_ssp_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremSsemInd_its__aid_raw_.fieldlength

	     LibItsSremSsem__TestSystem::SremInd_gnNextHeader_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremInd_gnHeaderType_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremInd_gnHeaderSubtype_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremInd_gnLifetime_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremInd_gnTrafficClass_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremInd_btpDestinationPort_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremInd_btpInfo_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremInd_ssp_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SremInd_its__aid_raw_.fieldlength

	     ) / 8;

    // Decode CA message

    if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const unsigned char *>(is)), cam) == -1) {

    if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const unsigned char *>(is)), srem) == -1) {

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

      return -1;

    }
@@ -76,91 +77,91 @@ namespace LibItsSremSsem__EncdecDeclarations { 
    TTCN_Buffer decoding_buffer(OCTETSTRING(s, static_cast<const unsigned char *>(is) + is.lengthof() - s));

    loggers::get_instance().log_to_hexa("fx__dec__SremInd: ", decoding_buffer);

    // gnNextHeader

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremSsemInd_gnNextHeader_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_gnNextHeader_raw_.fieldlength / 8)) {

      p_sremInd.gnNextHeader().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsSremSsem__TestSystem::SremSsemInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsSremSsem__TestSystem::SremInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.gnNextHeader() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__SremInd: gnNextHeader=", p_sremInd.gnNextHeader());

    loggers::get_instance().log_to_hexa("fx__dec__SremInd: ", decoding_buffer);

    // gnHeaderType

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremSsemInd_gnHeaderType_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_gnHeaderType_raw_.fieldlength / 8)) {

      p_sremInd.gnHeaderType().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsSremSsem__TestSystem::SremSsemInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsSremSsem__TestSystem::SremInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.gnHeaderType() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__Srem: gnHeaderType=", p_sremInd.gnHeaderType());

    loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);

    // gnHeaderSubtype

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremSsemInd_gnHeaderSubtype_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_gnHeaderSubtype_raw_.fieldlength / 8)) {

      p_sremInd.gnHeaderSubtype().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsSremSsem__TestSystem::SremSsemInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsSremSsem__TestSystem::SremInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.gnHeaderSubtype() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__Srem: gnHeaderSubtype=", p_sremInd.gnHeaderSubtype());

    loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);

    // gnLifetime

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremSsemInd_gnLifetime_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_gnLifetime_raw_.fieldlength / 8)) {

      p_sremInd.gnLifetime().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsSremSsem__TestSystem::SremSsemInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsSremSsem__TestSystem::SremInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.gnLifetime() = i;

    }

    loggers::get_instance().log_msg("fx__dec__Srem: gnLifetime=", p_sremInd.gnLifetime());

    loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);

    // gnTrafficClass

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremSsemInd_gnTrafficClass_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_gnTrafficClass_raw_.fieldlength / 8)) {

      p_sremInd.gnTrafficClass().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsSremSsem__TestSystem::SremSsemInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsSremSsem__TestSystem::SremInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.gnTrafficClass() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__Srem: gnTrafficClass=", p_sremInd.gnTrafficClass());

    loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);

    // btpDestinationPort

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremSsemInd_btpDestinationPort_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_btpDestinationPort_raw_.fieldlength / 8)) {

      p_sremInd.btpDestinationPort().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsSremSsem__TestSystem::SremSsemInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsSremSsem__TestSystem::SremInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.btpDestinationPort() = i;

    }

    loggers::get_instance().log_msg("fx__dec__Srem: btpDestinationPort=", p_sremInd.btpDestinationPort());

    loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);

    // btpInfo

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremSsemInd_btpInfo_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_btpInfo_raw_.fieldlength / 8)) {

      p_sremInd.btpInfo().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsSremSsem__TestSystem::SremSsemInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsSremSsem__TestSystem::SremInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.btpInfo() = i;

    }

    loggers::get_instance().log_msg("fx__dec__Srem: btpInfo=", p_sremInd.btpInfo());

    loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);

    // ssp

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremSsemInd_ssp_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_ssp_raw_.fieldlength / 8)) {

      p_sremInd.ssp().set_to_omit();

    } else {

      BITSTRING bs;

      bs.decode(LibItsSremSsem__TestSystem::SremSsemInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      bs.decode(LibItsSremSsem__TestSystem::SremInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.ssp() = bs;

    }

    loggers::get_instance().log_msg("fx__dec__Srem: ssp=", p_sremInd.ssp());

    loggers::get_instance().log_to_hexa("fx__dec__Srem: ", decoding_buffer);

    // its__aid

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremSsemInd_its__aid_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SremInd_its__aid_raw_.fieldlength / 8)) {

      p_sremInd.its__aid().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsSremSsem__TestSystem::SremSsemInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsSremSsem__TestSystem::SremInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.its__aid() = i;

    }

    loggers::get_instance().log_msg("fx__dec__Srem: its_aid=", p_sremInd.its__aid());
@@ -173,7 +174,7 @@ namespace LibItsSremSsem__EncdecDeclarations { 
  {

    loggers::get_instance().log_msg(">>> fx__enc__Srem: ", p_srem);

    

    SremSsemCodec codec;

    SremCodec codec;

    OCTETSTRING os;

    codec.encode(p_srem, os);

    return oct2bit(os);
@@ -182,7 +183,7 @@ namespace LibItsSremSsem__EncdecDeclarations { 
  INTEGER fx__dec__Srem(BITSTRING& b, SREM__PDU__Descriptions::SREM& p)

  {

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

    SremSsemCodec codec;

    SremCodec codec;

    OCTETSTRING is = bit2oct(b);



    if (codec.decode(OCTETSTRING(is.lengthof(), static_cast<const unsigned char *>(is)), p) == -1) {
@@ -198,13 +199,13 @@ namespace LibItsSremSsem__EncdecDeclarations { 
   * @param   value to encode

   * @return  encoded value

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

  BITSTRING fx__enc__SsemReq(const LibItsSsemSsem__TestSystem::SsemReq& p_sremReq)

  BITSTRING fx__enc__SsemReq(const LibItsSremSsem__TestSystem::SsemReq& p_ssemReq)

  {

    loggers::get_instance().log_msg(">>> fx__enc__SsemReq: ", p_sremReq);

    loggers::get_instance().log_msg(">>> fx__enc__SsemReq: ", p_ssemReq);

    

    SsemSsemCodec codec;

    SsemCodec codec;

    OCTETSTRING os;

    if (codec.encode(p_sremReq.msgOut(), os) == -1) {

    if (codec.encode(p_ssemReq.msgOut(), os) == -1) {

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

      return int2bit(0, 1);

    }
@@ -217,12 +218,12 @@ namespace LibItsSremSsem__EncdecDeclarations { 
   * @param   value to encode

   * @return  encoded value

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

  INTEGER fx__dec__SsemReq(BITSTRING& b, LibItsSsemSsem__TestSystem::SsemReq& p)

  INTEGER fx__dec__SsemReq(BITSTRING& b, LibItsSremSsem__TestSystem::SsemReq& p)

  {

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



    SsemSsemCodec codec;

    SSEM_PDU_Descriptions::SSEM ssem;

    SsemCodec codec;

    SSEM__PDU__Descriptions::SSEM ssem;

    OCTETSTRING is = bit2oct(b);



    if (codec.decode(is, ssem) == -1) {
@@ -234,124 +235,124 @@ namespace LibItsSremSsem__EncdecDeclarations { 
    return 0;

  }



  INTEGER fx__dec__SsemInd(BITSTRING& b, LibItsSsemSsem__TestSystem::SsemInd& p_sremInd)

  INTEGER fx__dec__SsemInd(BITSTRING& b, LibItsSremSsem__TestSystem::SsemInd& p_ssemInd)

  {

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

    

    SsemSsemCodec codec;

    SSEM_PDU_Descriptions::SSEM ssem;

    SsemCodec codec;

    SSEM__PDU__Descriptions::SSEM ssem;

    OCTETSTRING is = bit2oct(b);



    // Calculate the size of the lower layers information

    int s = (

	     LibItsSsemSsem__TestSystem::SsemSsemInd_gnNextHeader_raw_.fieldlength +

	     LibItsSsemSsem__TestSystem::SsemSsemInd_gnHeaderType_raw_.fieldlength +

	     LibItsSsemSsem__TestSystem::SsemSsemInd_gnHeaderSubtype_raw_.fieldlength +

	     LibItsSsemSsem__TestSystem::SsemSsemInd_gnLifetime_raw_.fieldlength +

	     LibItsSsemSsem__TestSystem::SsemSsemInd_gnTrafficClass_raw_.fieldlength +

	     LibItsSsemSsem__TestSystem::SsemSsemInd_btpDestinationPort_raw_.fieldlength +

	     LibItsSsemSsem__TestSystem::SsemSsemInd_btpInfo_raw_.fieldlength +

	     LibItsSsemSsem__TestSystem::SsemSsemInd_ssp_raw_.fieldlength +

	     LibItsSsemSsem__TestSystem::SsemSsemInd_its__aid_raw_.fieldlength

	     LibItsSremSsem__TestSystem::SsemInd_gnNextHeader_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SsemInd_gnHeaderType_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SsemInd_gnHeaderSubtype_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SsemInd_gnLifetime_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SsemInd_gnTrafficClass_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SsemInd_btpDestinationPort_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SsemInd_btpInfo_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SsemInd_ssp_raw_.fieldlength +

	     LibItsSremSsem__TestSystem::SsemInd_its__aid_raw_.fieldlength

	     ) / 8;

    // Decode CA message

    if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const unsigned char *>(is)), ssem) == -1) {

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

      return -1;

    }

    p_sremInd.msgIn() = ssem;

    p_ssemInd.msgIn() = ssem;

    // Decode lower layer data

    TTCN_Buffer decoding_buffer(OCTETSTRING(s, static_cast<const unsigned char *>(is) + is.lengthof() - s));

    loggers::get_instance().log_to_hexa("fx__dec__SsemInd: ", decoding_buffer);

    // gnNextHeader

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSsemSsem__TestSystem::SsemSsemInd_gnNextHeader_raw_.fieldlength / 8)) {

      p_sremInd.gnNextHeader().set_to_omit();

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_gnNextHeader_raw_.fieldlength / 8)) {

      p_ssemInd.gnNextHeader().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsSsemSsem__TestSystem::SsemSsemInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.gnNextHeader() = oct2int(os);

      os.decode(LibItsSremSsem__TestSystem::SsemInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ssemInd.gnNextHeader() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__SsemInd: gnNextHeader=", p_sremInd.gnNextHeader());

    loggers::get_instance().log_msg("fx__dec__SsemInd: gnNextHeader=", p_ssemInd.gnNextHeader());

    loggers::get_instance().log_to_hexa("fx__dec__SsemInd: ", decoding_buffer);

    // gnHeaderType

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSsemSsem__TestSystem::SsemSsemInd_gnHeaderType_raw_.fieldlength / 8)) {

      p_sremInd.gnHeaderType().set_to_omit();

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_gnHeaderType_raw_.fieldlength / 8)) {

      p_ssemInd.gnHeaderType().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsSsemSsem__TestSystem::SsemSsemInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.gnHeaderType() = oct2int(os);

      os.decode(LibItsSremSsem__TestSystem::SsemInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ssemInd.gnHeaderType() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__Ssem: gnHeaderType=", p_sremInd.gnHeaderType());

    loggers::get_instance().log_msg("fx__dec__Ssem: gnHeaderType=", p_ssemInd.gnHeaderType());

    loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);

    // gnHeaderSubtype

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSsemSsem__TestSystem::SsemSsemInd_gnHeaderSubtype_raw_.fieldlength / 8)) {

      p_sremInd.gnHeaderSubtype().set_to_omit();

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_gnHeaderSubtype_raw_.fieldlength / 8)) {

      p_ssemInd.gnHeaderSubtype().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsSsemSsem__TestSystem::SsemSsemInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.gnHeaderSubtype() = oct2int(os);

      os.decode(LibItsSremSsem__TestSystem::SsemInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ssemInd.gnHeaderSubtype() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__Ssem: gnHeaderSubtype=", p_sremInd.gnHeaderSubtype());

    loggers::get_instance().log_msg("fx__dec__Ssem: gnHeaderSubtype=", p_ssemInd.gnHeaderSubtype());

    loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);

    // gnLifetime

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSsemSsem__TestSystem::SsemSsemInd_gnLifetime_raw_.fieldlength / 8)) {

      p_sremInd.gnLifetime().set_to_omit();

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_gnLifetime_raw_.fieldlength / 8)) {

      p_ssemInd.gnLifetime().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsSsemSsem__TestSystem::SsemSsemInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.gnLifetime() = i;

      i.decode(LibItsSremSsem__TestSystem::SsemInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ssemInd.gnLifetime() = i;

    }

    loggers::get_instance().log_msg("fx__dec__Ssem: gnLifetime=", p_sremInd.gnLifetime());

    loggers::get_instance().log_msg("fx__dec__Ssem: gnLifetime=", p_ssemInd.gnLifetime());

    loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);

    // gnTrafficClass

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSsemSsem__TestSystem::SsemSsemInd_gnTrafficClass_raw_.fieldlength / 8)) {

      p_sremInd.gnTrafficClass().set_to_omit();

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_gnTrafficClass_raw_.fieldlength / 8)) {

      p_ssemInd.gnTrafficClass().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsSsemSsem__TestSystem::SsemSsemInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.gnTrafficClass() = oct2int(os);

      os.decode(LibItsSremSsem__TestSystem::SsemInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ssemInd.gnTrafficClass() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__Ssem: gnTrafficClass=", p_sremInd.gnTrafficClass());

    loggers::get_instance().log_msg("fx__dec__Ssem: gnTrafficClass=", p_ssemInd.gnTrafficClass());

    loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);

    // btpDestinationPort

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSsemSsem__TestSystem::SsemSsemInd_btpDestinationPort_raw_.fieldlength / 8)) {

      p_sremInd.btpDestinationPort().set_to_omit();

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_btpDestinationPort_raw_.fieldlength / 8)) {

      p_ssemInd.btpDestinationPort().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsSsemSsem__TestSystem::SsemSsemInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.btpDestinationPort() = i;

      i.decode(LibItsSremSsem__TestSystem::SsemInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ssemInd.btpDestinationPort() = i;

    }

    loggers::get_instance().log_msg("fx__dec__Ssem: btpDestinationPort=", p_sremInd.btpDestinationPort());

    loggers::get_instance().log_msg("fx__dec__Ssem: btpDestinationPort=", p_ssemInd.btpDestinationPort());

    loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);

    // btpInfo

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSsemSsem__TestSystem::SsemSsemInd_btpInfo_raw_.fieldlength / 8)) {

      p_sremInd.btpInfo().set_to_omit();

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_btpInfo_raw_.fieldlength / 8)) {

      p_ssemInd.btpInfo().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsSsemSsem__TestSystem::SsemSsemInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.btpInfo() = i;

      i.decode(LibItsSremSsem__TestSystem::SsemInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ssemInd.btpInfo() = i;

    }

    loggers::get_instance().log_msg("fx__dec__Ssem: btpInfo=", p_sremInd.btpInfo());

    loggers::get_instance().log_msg("fx__dec__Ssem: btpInfo=", p_ssemInd.btpInfo());

    loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);

    // ssp

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSsemSsem__TestSystem::SsemSsemInd_ssp_raw_.fieldlength / 8)) {

      p_sremInd.ssp().set_to_omit();

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_ssp_raw_.fieldlength / 8)) {

      p_ssemInd.ssp().set_to_omit();

    } else {

      BITSTRING bs;

      bs.decode(LibItsSsemSsem__TestSystem::SsemSsemInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.ssp() = bs;

      bs.decode(LibItsSremSsem__TestSystem::SsemInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ssemInd.ssp() = bs;

    }

    loggers::get_instance().log_msg("fx__dec__Ssem: ssp=", p_sremInd.ssp());

    loggers::get_instance().log_msg("fx__dec__Ssem: ssp=", p_ssemInd.ssp());

    loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);

    // its__aid

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSsemSsem__TestSystem::SsemSsemInd_its__aid_raw_.fieldlength / 8)) {

      p_sremInd.its__aid().set_to_omit();

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSremSsem__TestSystem::SsemInd_its__aid_raw_.fieldlength / 8)) {

      p_ssemInd.its__aid().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsSsemSsem__TestSystem::SsemSsemInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_sremInd.its__aid() = i;

      i.decode(LibItsSremSsem__TestSystem::SsemInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ssemInd.its__aid() = i;

    }

    loggers::get_instance().log_msg("fx__dec__Ssem: its_aid=", p_sremInd.its__aid());

    loggers::get_instance().log_msg("fx__dec__Ssem: its_aid=", p_ssemInd.its__aid());

    loggers::get_instance().log_to_hexa("fx__dec__Ssem: ", decoding_buffer);

    

    return 0;
@@ -361,7 +362,7 @@ namespace LibItsSremSsem__EncdecDeclarations { 
  {

    loggers::get_instance().log_msg(">>> fx__enc__Ssem: ", p_ssem);

    

    SsemSsemCodec codec;

    SsemCodec codec;

    OCTETSTRING os;

    codec.encode(p_ssem, os);

    return oct2bit(os);
@@ -370,7 +371,7 @@ namespace LibItsSremSsem__EncdecDeclarations { 
  INTEGER fx__dec__Ssem(BITSTRING& b, SSEM__PDU__Descriptions::SSEM& p_ssem)

  {

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

    SsemSsemCodec codec;

    SsemCodec codec;

    OCTETSTRING is = bit2oct(b);



    if (codec.decode(OCTETSTRING(is.lengthof(), static_cast<const unsigned char *>(is)), p_ssem) == -1) {
@@ -406,18 +407,18 @@ namespace LibItsSremSsem__EncdecDeclarations { 
   * @param   value to encode

   * @return  encoded value

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

  INTEGER fx__dec__UtSremResults(BITSTRING& b, LibItsSrem__TypesAndValues::UtSremResults& p)

  INTEGER fx__dec__UtSremResults(BITSTRING& b, LibItsSremSsem__TypesAndValues::UtSremResults& p)

  {

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



    UpperTesterSremCodec codec;

    UpperTesterSremSsemCodec codec;

    OCTETSTRING is = bit2oct(b);

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

    if (ptr == nullptr) {

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

      return -1;

    }

    p = static_cast<LibItsSrem__TypesAndValues::UtSremResults&>(*ptr);

    p = static_cast<LibItsSremSsem__TypesAndValues::UtSremResults&>(*ptr);

    return 0;

  }
@@ -426,18 +427,18 @@ namespace LibItsSremSsem__EncdecDeclarations { 
   * @param   value to encode

   * @return  encoded value

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

  INTEGER fx__dec__UtSremEventInd(BITSTRING& b, LibItsSrem__TypesAndValues::UtSremEventInd& p)

  INTEGER fx__dec__UtSremEventInd(BITSTRING& b, LibItsSremSsem__TypesAndValues::UtSremEventInd& p)

  {

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



    UpperTesterSremCodec codec;

    UpperTesterSremSsemCodec codec;

    OCTETSTRING is = bit2oct(b);

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

    if (ptr == nullptr) {

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

      return -1;

    }

    p = static_cast<LibItsSrem__TypesAndValues::UtSremEventInd&>(*ptr);

    p = static_cast<LibItsSremSsem__TypesAndValues::UtSremEventInd&>(*ptr);

    return 0;

  }
@@ -446,18 +447,18 @@ namespace LibItsSremSsem__EncdecDeclarations { 
   * @param   value to encode

   * @return  encoded value

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

  INTEGER fx__dec__UtSsemEventInd(BITSTRING& b, LibItsSsem__TypesAndValues::UtSsemEventInd& p)

  INTEGER fx__dec__UtSsemEventInd(BITSTRING& b, LibItsSremSsem__TypesAndValues::UtSsemEventInd& p)

  {

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



    UpperTesterSsemCodec codec;

    UpperTesterSremSsemCodec codec;

    OCTETSTRING is = bit2oct(b);

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

    if (ptr == nullptr) {

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

      return -1;

    }

    p = static_cast<LibItsSsem__TypesAndValues::UtSsemEventInd&>(*ptr);

    p = static_cast<LibItsSremSsem__TypesAndValues::UtSsemEventInd&>(*ptr);

    return 0;

  }

ccsrc/Framework/Codec.hh

+52 −11

File changed.

Preview size limit exceeded, changes collapsed.

ccsrc/Framework/Layer.hh

+19 −1

File changed.

Preview size limit exceeded, changes collapsed.