Commit d6808612 authored by YannGarcia's avatar YannGarcia
Browse files

Rebuild AtsIS based on TITAN iso-patch

parent 17434943

ccsrc/EncDec/LibItsIvim_Encdec.cc

+26 −26
Original line number Diff line number Diff line
@@ -12,7 +12,7 @@ namespace LibItsIvim__EncdecDeclarations { 
   * @param   value to encode

   * @return  encoded value

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

  BITSTRING fx__enc__IvimReq(const LibItsIvim__TestSystem::IvimReq &p_ivimReq) {

  BITSTRING fx__enc__IvimReq(const LibItsIvim__TypesAndValues::IvimReq &p_ivimReq) {

    loggers::get_instance().log_msg(">>> fx__enc__IvimReq: ", p_ivimReq);



    ivim_codec  codec;
@@ -30,7 +30,7 @@ namespace LibItsIvim__EncdecDeclarations { 
   * @param   value to encode

   * @return  encoded value

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

  INTEGER fx__dec__IvimReq(BITSTRING &b, LibItsIvim__TestSystem::IvimReq &p) {

  INTEGER fx__dec__IvimReq(BITSTRING &b, LibItsIvim__TypesAndValues::IvimReq &p) {

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



    ivim_codec                    codec;
@@ -46,7 +46,7 @@ namespace LibItsIvim__EncdecDeclarations { 
    return 0;

  }



  INTEGER fx__dec__IvimInd(BITSTRING &b, LibItsIvim__TestSystem::IvimInd &p_ivimInd) {

  INTEGER fx__dec__IvimInd(BITSTRING &b, LibItsIvim__TypesAndValues::IvimInd &p_ivimInd) {

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



    ivim_codec                    codec;
@@ -54,11 +54,11 @@ namespace LibItsIvim__EncdecDeclarations { 
    OCTETSTRING                   is = bit2oct(b);



    // Calculate the size of the lower layers information

    int s = (LibItsIvim__TestSystem::IvimInd_gnNextHeader_raw_.fieldlength + LibItsIvim__TestSystem::IvimInd_gnHeaderType_raw_.fieldlength +

             LibItsIvim__TestSystem::IvimInd_gnHeaderSubtype_raw_.fieldlength + LibItsIvim__TestSystem::IvimInd_gnLifetime_raw_.fieldlength +

             LibItsIvim__TestSystem::IvimInd_gnTrafficClass_raw_.fieldlength + LibItsIvim__TestSystem::IvimInd_btpDestinationPort_raw_.fieldlength +

             LibItsIvim__TestSystem::IvimInd_btpInfo_raw_.fieldlength + LibItsIvim__TestSystem::IvimInd_ssp_raw_.fieldlength +

             LibItsIvim__TestSystem::IvimInd_its__aid_raw_.fieldlength) /

    int s = (LibItsIvim__TypesAndValues::IvimInd_gnNextHeader_raw_.fieldlength + LibItsIvim__TypesAndValues::IvimInd_gnHeaderType_raw_.fieldlength +

             LibItsIvim__TypesAndValues::IvimInd_gnHeaderSubtype_raw_.fieldlength + LibItsIvim__TypesAndValues::IvimInd_gnLifetime_raw_.fieldlength +

             LibItsIvim__TypesAndValues::IvimInd_gnTrafficClass_raw_.fieldlength + LibItsIvim__TypesAndValues::IvimInd_btpDestinationPort_raw_.fieldlength +

             LibItsIvim__TypesAndValues::IvimInd_btpInfo_raw_.fieldlength + LibItsIvim__TypesAndValues::IvimInd_ssp_raw_.fieldlength +

             LibItsIvim__TypesAndValues::IvimInd_its__aid_raw_.fieldlength) /

            8;

    // Decode CA message

    if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const unsigned char *>(is)), ivim) == -1) {
@@ -70,91 +70,91 @@ namespace LibItsIvim__EncdecDeclarations { 
    TTCN_Buffer decoding_buffer(OCTETSTRING(s, static_cast<const unsigned char *>(is) + is.lengthof() - s));

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

    // gnNextHeader

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TestSystem::IvimInd_gnNextHeader_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TypesAndValues::IvimInd_gnNextHeader_raw_.fieldlength / 8)) {

      p_ivimInd.gnNextHeader().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsIvim__TestSystem::IvimInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsIvim__TypesAndValues::IvimInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ivimInd.gnNextHeader() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__IVIM: gnNextHeader=", p_ivimInd.gnNextHeader());

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

    // gnHeaderType

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TestSystem::IvimInd_gnHeaderType_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TypesAndValues::IvimInd_gnHeaderType_raw_.fieldlength / 8)) {

      p_ivimInd.gnHeaderType().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsIvim__TestSystem::IvimInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsIvim__TypesAndValues::IvimInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ivimInd.gnHeaderType() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__IVIM: gnHeaderType=", p_ivimInd.gnHeaderType());

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

    // gnHeaderSubtype

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TestSystem::IvimInd_gnHeaderSubtype_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TypesAndValues::IvimInd_gnHeaderSubtype_raw_.fieldlength / 8)) {

      p_ivimInd.gnHeaderSubtype().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsIvim__TestSystem::IvimInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsIvim__TypesAndValues::IvimInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ivimInd.gnHeaderSubtype() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__IVIM: gnHeaderSubtype=", p_ivimInd.gnHeaderSubtype());

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

    // gnLifetime

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TestSystem::IvimInd_gnLifetime_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TypesAndValues::IvimInd_gnLifetime_raw_.fieldlength / 8)) {

      p_ivimInd.gnLifetime().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsIvim__TestSystem::IvimInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsIvim__TypesAndValues::IvimInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ivimInd.gnLifetime() = i;

    }

    loggers::get_instance().log_msg("fx__dec__IVIM: gnLifetime=", p_ivimInd.gnLifetime());

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

    // gnTrafficClass

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TestSystem::IvimInd_gnTrafficClass_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TypesAndValues::IvimInd_gnTrafficClass_raw_.fieldlength / 8)) {

      p_ivimInd.gnTrafficClass().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsIvim__TestSystem::IvimInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsIvim__TypesAndValues::IvimInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ivimInd.gnTrafficClass() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__IVIM: gnTrafficClass=", p_ivimInd.gnTrafficClass());

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

    // btpDestinationPort

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TestSystem::IvimInd_btpDestinationPort_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TypesAndValues::IvimInd_btpDestinationPort_raw_.fieldlength / 8)) {

      p_ivimInd.btpDestinationPort().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsIvim__TestSystem::IvimInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsIvim__TypesAndValues::IvimInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ivimInd.btpDestinationPort() = i;

    }

    loggers::get_instance().log_msg("fx__dec__IVIM: btpDestinationPort=", p_ivimInd.btpDestinationPort());

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

    // btpInfo

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TestSystem::IvimInd_btpInfo_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TypesAndValues::IvimInd_btpInfo_raw_.fieldlength / 8)) {

      p_ivimInd.btpInfo().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsIvim__TestSystem::IvimInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsIvim__TypesAndValues::IvimInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ivimInd.btpInfo() = i;

    }

    loggers::get_instance().log_msg("fx__dec__IVIM: btpInfo=", p_ivimInd.btpInfo());

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

    // ssp

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TestSystem::IvimInd_ssp_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TypesAndValues::IvimInd_ssp_raw_.fieldlength / 8)) {

      p_ivimInd.ssp().set_to_omit();

    } else {

      BITSTRING bs;

      bs.decode(LibItsIvim__TestSystem::IvimInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      bs.decode(LibItsIvim__TypesAndValues::IvimInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ivimInd.ssp() = bs;

    }

    loggers::get_instance().log_msg("fx__dec__IVIM: ssp=", p_ivimInd.ssp());

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

    // its__aid

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TestSystem::IvimInd_its__aid_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsIvim__TypesAndValues::IvimInd_its__aid_raw_.fieldlength / 8)) {

      p_ivimInd.its__aid().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsIvim__TestSystem::IvimInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsIvim__TypesAndValues::IvimInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_ivimInd.its__aid() = i;

    }

    loggers::get_instance().log_msg("fx__dec__IVIM: its_aid=", p_ivimInd.its__aid());

ccsrc/EncDec/LibItsMapemSpatem_Encdec.cc

+52 −52

File changed.

Preview size limit exceeded, changes collapsed.

ccsrc/EncDec/LibItsRtcmem_Encdec.cc

+26 −26
Original line number Diff line number Diff line
@@ -12,7 +12,7 @@ namespace LibItsRtcmem__EncdecDeclarations { 
   * @param   value to encode

   * @return  encoded value

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

  BITSTRING fx__enc__RtcmemReq(const LibItsRtcmem__TestSystem::RtcmemReq &p_rtcmemReq) {

  BITSTRING fx__enc__RtcmemReq(const LibItsRtcmem__TypesAndValues::RtcmemReq &p_rtcmemReq) {

    loggers::get_instance().log_msg(">>> fx__enc__RtcmemReq: ", p_rtcmemReq);



    RtcmemCodec codec;
@@ -30,7 +30,7 @@ namespace LibItsRtcmem__EncdecDeclarations { 
   * @param   value to encode

   * @return  encoded value

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

  INTEGER fx__dec__RtcmemReq(BITSTRING &b, LibItsRtcmem__TestSystem::RtcmemReq &p) {

  INTEGER fx__dec__RtcmemReq(BITSTRING &b, LibItsRtcmem__TypesAndValues::RtcmemReq &p) {

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



    RtcmemCodec                       codec;
@@ -46,7 +46,7 @@ namespace LibItsRtcmem__EncdecDeclarations { 
    return 0;

  }



  INTEGER fx__dec__RtcmemInd(BITSTRING &b, LibItsRtcmem__TestSystem::RtcmemInd &p_rtcmemInd) {

  INTEGER fx__dec__RtcmemInd(BITSTRING &b, LibItsRtcmem__TypesAndValues::RtcmemInd &p_rtcmemInd) {

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



    RtcmemCodec                       codec;
@@ -54,11 +54,11 @@ namespace LibItsRtcmem__EncdecDeclarations { 
    OCTETSTRING                       is = bit2oct(b);



    // Calculate the size of the lower layers information

    int s = (LibItsRtcmem__TestSystem::RtcmemInd_gnNextHeader_raw_.fieldlength + LibItsRtcmem__TestSystem::RtcmemInd_gnHeaderType_raw_.fieldlength +

             LibItsRtcmem__TestSystem::RtcmemInd_gnHeaderSubtype_raw_.fieldlength + LibItsRtcmem__TestSystem::RtcmemInd_gnLifetime_raw_.fieldlength +

             LibItsRtcmem__TestSystem::RtcmemInd_gnTrafficClass_raw_.fieldlength + LibItsRtcmem__TestSystem::RtcmemInd_btpDestinationPort_raw_.fieldlength +

             LibItsRtcmem__TestSystem::RtcmemInd_btpInfo_raw_.fieldlength + LibItsRtcmem__TestSystem::RtcmemInd_ssp_raw_.fieldlength +

             LibItsRtcmem__TestSystem::RtcmemInd_its__aid_raw_.fieldlength) /

    int s = (LibItsRtcmem__TypesAndValues::RtcmemInd_gnNextHeader_raw_.fieldlength + LibItsRtcmem__TypesAndValues::RtcmemInd_gnHeaderType_raw_.fieldlength +

             LibItsRtcmem__TypesAndValues::RtcmemInd_gnHeaderSubtype_raw_.fieldlength + LibItsRtcmem__TypesAndValues::RtcmemInd_gnLifetime_raw_.fieldlength +

             LibItsRtcmem__TypesAndValues::RtcmemInd_gnTrafficClass_raw_.fieldlength + LibItsRtcmem__TypesAndValues::RtcmemInd_btpDestinationPort_raw_.fieldlength +

             LibItsRtcmem__TypesAndValues::RtcmemInd_btpInfo_raw_.fieldlength + LibItsRtcmem__TypesAndValues::RtcmemInd_ssp_raw_.fieldlength +

             LibItsRtcmem__TypesAndValues::RtcmemInd_its__aid_raw_.fieldlength) /

            8;

    // Decode CA message

    if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const unsigned char *>(is)), rtcmem) == -1) {
@@ -70,91 +70,91 @@ namespace LibItsRtcmem__EncdecDeclarations { 
    TTCN_Buffer decoding_buffer(OCTETSTRING(s, static_cast<const unsigned char *>(is) + is.lengthof() - s));

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

    // gnNextHeader

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TestSystem::RtcmemInd_gnNextHeader_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TypesAndValues::RtcmemInd_gnNextHeader_raw_.fieldlength / 8)) {

      p_rtcmemInd.gnNextHeader().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsRtcmem__TestSystem::RtcmemInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsRtcmem__TypesAndValues::RtcmemInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_rtcmemInd.gnNextHeader() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__RTCMEM: gnNextHeader=", p_rtcmemInd.gnNextHeader());

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

    // gnHeaderType

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TestSystem::RtcmemInd_gnHeaderType_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TypesAndValues::RtcmemInd_gnHeaderType_raw_.fieldlength / 8)) {

      p_rtcmemInd.gnHeaderType().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsRtcmem__TestSystem::RtcmemInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsRtcmem__TypesAndValues::RtcmemInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_rtcmemInd.gnHeaderType() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__RTCMEM: gnHeaderType=", p_rtcmemInd.gnHeaderType());

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

    // gnHeaderSubtype

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TestSystem::RtcmemInd_gnHeaderSubtype_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TypesAndValues::RtcmemInd_gnHeaderSubtype_raw_.fieldlength / 8)) {

      p_rtcmemInd.gnHeaderSubtype().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsRtcmem__TestSystem::RtcmemInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsRtcmem__TypesAndValues::RtcmemInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_rtcmemInd.gnHeaderSubtype() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__RTCMEM: gnHeaderSubtype=", p_rtcmemInd.gnHeaderSubtype());

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

    // gnLifetime

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TestSystem::RtcmemInd_gnLifetime_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TypesAndValues::RtcmemInd_gnLifetime_raw_.fieldlength / 8)) {

      p_rtcmemInd.gnLifetime().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsRtcmem__TestSystem::RtcmemInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsRtcmem__TypesAndValues::RtcmemInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_rtcmemInd.gnLifetime() = i;

    }

    loggers::get_instance().log_msg("fx__dec__RTCMEM: gnLifetime=", p_rtcmemInd.gnLifetime());

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

    // gnTrafficClass

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TestSystem::RtcmemInd_gnTrafficClass_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TypesAndValues::RtcmemInd_gnTrafficClass_raw_.fieldlength / 8)) {

      p_rtcmemInd.gnTrafficClass().set_to_omit();

    } else {

      OCTETSTRING os;

      os.decode(LibItsRtcmem__TestSystem::RtcmemInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      os.decode(LibItsRtcmem__TypesAndValues::RtcmemInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_rtcmemInd.gnTrafficClass() = oct2int(os);

    }

    loggers::get_instance().log_msg("fx__dec__RTCMEM: gnTrafficClass=", p_rtcmemInd.gnTrafficClass());

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

    // btpDestinationPort

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TestSystem::RtcmemInd_btpDestinationPort_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TypesAndValues::RtcmemInd_btpDestinationPort_raw_.fieldlength / 8)) {

      p_rtcmemInd.btpDestinationPort().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsRtcmem__TestSystem::RtcmemInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsRtcmem__TypesAndValues::RtcmemInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_rtcmemInd.btpDestinationPort() = i;

    }

    loggers::get_instance().log_msg("fx__dec__RTCMEM: btpDestinationPort=", p_rtcmemInd.btpDestinationPort());

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

    // btpInfo

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TestSystem::RtcmemInd_btpInfo_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TypesAndValues::RtcmemInd_btpInfo_raw_.fieldlength / 8)) {

      p_rtcmemInd.btpInfo().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsRtcmem__TestSystem::RtcmemInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsRtcmem__TypesAndValues::RtcmemInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_rtcmemInd.btpInfo() = i;

    }

    loggers::get_instance().log_msg("fx__dec__RTCMEM: btpInfo=", p_rtcmemInd.btpInfo());

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

    // ssp

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TestSystem::RtcmemInd_ssp_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TypesAndValues::RtcmemInd_ssp_raw_.fieldlength / 8)) {

      p_rtcmemInd.ssp().set_to_omit();

    } else {

      BITSTRING bs;

      bs.decode(LibItsRtcmem__TestSystem::RtcmemInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      bs.decode(LibItsRtcmem__TypesAndValues::RtcmemInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_rtcmemInd.ssp() = bs;

    }

    loggers::get_instance().log_msg("fx__dec__RTCMEM: ssp=", p_rtcmemInd.ssp());

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

    // its__aid

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TestSystem::RtcmemInd_its__aid_raw_.fieldlength / 8)) {

    if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsRtcmem__TypesAndValues::RtcmemInd_its__aid_raw_.fieldlength / 8)) {

      p_rtcmemInd.its__aid().set_to_omit();

    } else {

      INTEGER i;

      i.decode(LibItsRtcmem__TestSystem::RtcmemInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      i.decode(LibItsRtcmem__TypesAndValues::RtcmemInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);

      p_rtcmemInd.its__aid() = i;

    }

    loggers::get_instance().log_msg("fx__dec__RTCMEM: its_aid=", p_rtcmemInd.its__aid());

ccsrc/EncDec/LibItsSremSsem_Encdec.cc

+54 −54

File changed.

Preview size limit exceeded, changes collapsed.

ccsrc/EncDec/module.mk

+4 −4
Original line number Diff line number Diff line
@@ -40,10 +40,10 @@ sources += \ 
endif



ifeq (AtsIS, $(ATS))

sources += LibItsIvim_Encdec.cc LibItsBtp_Encdec.cc \

           LibItsSremSsem_Encdec.cc LibItsBtp_Encdec.cc \

           LibItsMapemSpatem_Encdec.cc LibItsBtp_Encdec.cc \

           LibItsRtcmem_Encdec.cc LibItsBtp_Encdec.cc

sources += LibItsIvim_Encdec.cc \

           LibItsSremSsem_Encdec.cc \

           LibItsMapemSpatem_Encdec.cc \

           LibItsRtcmem_Encdec.cc

endif



ifeq (AtsPki, $(ATS))