// This C++ source file was generated by the TTCN-3 compiler // of the TTCN-3 Test Executor version 9.0.0 // for (build@3978f7fbee0c) on Mon Jun 24 02:37:33 2024 // Copyright (c) 2000-2023 Ericsson Telecom AB // Do not edit this file unless you know what you are doing. /* Including header files */ #include "GTPC_Types.hh" namespace GTPC__Types { /* Member functions of C++ classes */ MS__InfoChangeNotificationResponse::MS__InfoChangeNotificationResponse() { } MS__InfoChangeNotificationResponse::MS__InfoChangeNotificationResponse(const Cause__gtpc& par_cause, const OPTIONAL< IMSI__gtpc >& par_imsi, const OPTIONAL< NSAPI__GTPC >& par_linkedNSAPI, const OPTIONAL< IMEISV__gtpc >& par_imeisv__gtpc, const OPTIONAL< MS__InfoChangeReportingAction >& par_mS__InfoChangeReportingAction, const OPTIONAL< CSGInfoReportingAction >& par_cSGInfoReportingAction, const OPTIONAL< PrivateExtension__gtpc__List >& par_private__extension__gtpc) : field_cause(par_cause), field_imsi(par_imsi), field_linkedNSAPI(par_linkedNSAPI), field_imeisv__gtpc(par_imeisv__gtpc), field_mS__InfoChangeReportingAction(par_mS__InfoChangeReportingAction), field_cSGInfoReportingAction(par_cSGInfoReportingAction), field_private__extension__gtpc(par_private__extension__gtpc) { } MS__InfoChangeNotificationResponse::MS__InfoChangeNotificationResponse(const MS__InfoChangeNotificationResponse& other_value) { if(!other_value.is_bound()) TTCN_error("Copying an unbound value of type @GTPC_Types.MS_InfoChangeNotificationResponse."); if (other_value.cause().is_bound()) field_cause = other_value.cause(); else field_cause.clean_up(); if (other_value.imsi().is_bound()) field_imsi = other_value.imsi(); else field_imsi.clean_up(); if (other_value.linkedNSAPI().is_bound()) field_linkedNSAPI = other_value.linkedNSAPI(); else field_linkedNSAPI.clean_up(); if (other_value.imeisv__gtpc().is_bound()) field_imeisv__gtpc = other_value.imeisv__gtpc(); else field_imeisv__gtpc.clean_up(); if (other_value.mS__InfoChangeReportingAction().is_bound()) field_mS__InfoChangeReportingAction = other_value.mS__InfoChangeReportingAction(); else field_mS__InfoChangeReportingAction.clean_up(); if (other_value.cSGInfoReportingAction().is_bound()) field_cSGInfoReportingAction = other_value.cSGInfoReportingAction(); else field_cSGInfoReportingAction.clean_up(); if (other_value.private__extension__gtpc().is_bound()) field_private__extension__gtpc = other_value.private__extension__gtpc(); else field_private__extension__gtpc.clean_up(); } void MS__InfoChangeNotificationResponse::clean_up() { field_cause.clean_up(); field_imsi.clean_up(); field_linkedNSAPI.clean_up(); field_imeisv__gtpc.clean_up(); field_mS__InfoChangeReportingAction.clean_up(); field_cSGInfoReportingAction.clean_up(); field_private__extension__gtpc.clean_up(); } const TTCN_Typedescriptor_t* MS__InfoChangeNotificationResponse::get_descriptor() const { return &MS__InfoChangeNotificationResponse_descr_; } MS__InfoChangeNotificationResponse& MS__InfoChangeNotificationResponse::operator=(const MS__InfoChangeNotificationResponse& other_value) { if (this != &other_value) { if(!other_value.is_bound()) TTCN_error("Assignment of an unbound value of type @GTPC_Types.MS_InfoChangeNotificationResponse."); if (other_value.cause().is_bound()) field_cause = other_value.cause(); else field_cause.clean_up(); if (other_value.imsi().is_bound()) field_imsi = other_value.imsi(); else field_imsi.clean_up(); if (other_value.linkedNSAPI().is_bound()) field_linkedNSAPI = other_value.linkedNSAPI(); else field_linkedNSAPI.clean_up(); if (other_value.imeisv__gtpc().is_bound()) field_imeisv__gtpc = other_value.imeisv__gtpc(); else field_imeisv__gtpc.clean_up(); if (other_value.mS__InfoChangeReportingAction().is_bound()) field_mS__InfoChangeReportingAction = other_value.mS__InfoChangeReportingAction(); else field_mS__InfoChangeReportingAction.clean_up(); if (other_value.cSGInfoReportingAction().is_bound()) field_cSGInfoReportingAction = other_value.cSGInfoReportingAction(); else field_cSGInfoReportingAction.clean_up(); if (other_value.private__extension__gtpc().is_bound()) field_private__extension__gtpc = other_value.private__extension__gtpc(); else field_private__extension__gtpc.clean_up(); } return *this; } boolean MS__InfoChangeNotificationResponse::operator==(const MS__InfoChangeNotificationResponse& other_value) const { return field_cause==other_value.field_cause && field_imsi==other_value.field_imsi && field_linkedNSAPI==other_value.field_linkedNSAPI && field_imeisv__gtpc==other_value.field_imeisv__gtpc && field_mS__InfoChangeReportingAction==other_value.field_mS__InfoChangeReportingAction && field_cSGInfoReportingAction==other_value.field_cSGInfoReportingAction && field_private__extension__gtpc==other_value.field_private__extension__gtpc; } boolean MS__InfoChangeNotificationResponse::is_bound() const { return (field_cause.is_bound()) || (OPTIONAL_OMIT == field_imsi.get_selection() || field_imsi.is_bound()) || (OPTIONAL_OMIT == field_linkedNSAPI.get_selection() || field_linkedNSAPI.is_bound()) || (OPTIONAL_OMIT == field_imeisv__gtpc.get_selection() || field_imeisv__gtpc.is_bound()) || (OPTIONAL_OMIT == field_mS__InfoChangeReportingAction.get_selection() || field_mS__InfoChangeReportingAction.is_bound()) || (OPTIONAL_OMIT == field_cSGInfoReportingAction.get_selection() || field_cSGInfoReportingAction.is_bound()) || (OPTIONAL_OMIT == field_private__extension__gtpc.get_selection() || field_private__extension__gtpc.is_bound()); } boolean MS__InfoChangeNotificationResponse::is_value() const { return field_cause.is_value() && (OPTIONAL_OMIT == field_imsi.get_selection() || field_imsi.is_value()) && (OPTIONAL_OMIT == field_linkedNSAPI.get_selection() || field_linkedNSAPI.is_value()) && (OPTIONAL_OMIT == field_imeisv__gtpc.get_selection() || field_imeisv__gtpc.is_value()) && (OPTIONAL_OMIT == field_mS__InfoChangeReportingAction.get_selection() || field_mS__InfoChangeReportingAction.is_value()) && (OPTIONAL_OMIT == field_cSGInfoReportingAction.get_selection() || field_cSGInfoReportingAction.is_value()) && (OPTIONAL_OMIT == field_private__extension__gtpc.get_selection() || field_private__extension__gtpc.is_value()); } int MS__InfoChangeNotificationResponse::size_of() const { int ret_val = 1; if (field_imsi.ispresent()) ret_val++; if (field_linkedNSAPI.ispresent()) ret_val++; if (field_imeisv__gtpc.ispresent()) ret_val++; if (field_mS__InfoChangeReportingAction.ispresent()) ret_val++; if (field_cSGInfoReportingAction.ispresent()) ret_val++; if (field_private__extension__gtpc.ispresent()) ret_val++; return ret_val; } void MS__InfoChangeNotificationResponse::log() const { if (!is_bound()) { TTCN_Logger::log_event_unbound(); return; } TTCN_Logger::log_event_str("{ cause := "); field_cause.log(); TTCN_Logger::log_event_str(", imsi := "); field_imsi.log(); TTCN_Logger::log_event_str(", linkedNSAPI := "); field_linkedNSAPI.log(); TTCN_Logger::log_event_str(", imeisv_gtpc := "); field_imeisv__gtpc.log(); TTCN_Logger::log_event_str(", mS_InfoChangeReportingAction := "); field_mS__InfoChangeReportingAction.log(); TTCN_Logger::log_event_str(", cSGInfoReportingAction := "); field_cSGInfoReportingAction.log(); TTCN_Logger::log_event_str(", private_extension_gtpc := "); field_private__extension__gtpc.log(); TTCN_Logger::log_event_str(" }"); } void MS__InfoChangeNotificationResponse::set_implicit_omit() { if (cause().is_bound()) cause().set_implicit_omit(); if (!imsi().is_bound()) imsi() = OMIT_VALUE; else imsi().set_implicit_omit(); if (!linkedNSAPI().is_bound()) linkedNSAPI() = OMIT_VALUE; else linkedNSAPI().set_implicit_omit(); if (!imeisv__gtpc().is_bound()) imeisv__gtpc() = OMIT_VALUE; else imeisv__gtpc().set_implicit_omit(); if (!mS__InfoChangeReportingAction().is_bound()) mS__InfoChangeReportingAction() = OMIT_VALUE; else mS__InfoChangeReportingAction().set_implicit_omit(); if (!cSGInfoReportingAction().is_bound()) cSGInfoReportingAction() = OMIT_VALUE; else cSGInfoReportingAction().set_implicit_omit(); if (!private__extension__gtpc().is_bound()) private__extension__gtpc() = OMIT_VALUE; else private__extension__gtpc().set_implicit_omit(); } void MS__InfoChangeNotificationResponse::set_param(Module_Param& param) { param.basic_check(Module_Param::BC_VALUE, "record value"); switch (param.get_type()) { case Module_Param::MP_Value_List: if (70 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) cause().set_param(*param.get_elem(0)); if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) imsi().set_param(*param.get_elem(1)); if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) linkedNSAPI().set_param(*param.get_elem(2)); if (param.get_size()>3 && param.get_elem(3)->get_type()!=Module_Param::MP_NotUsed) imeisv__gtpc().set_param(*param.get_elem(3)); if (param.get_size()>4 && param.get_elem(4)->get_type()!=Module_Param::MP_NotUsed) mS__InfoChangeReportingAction().set_param(*param.get_elem(4)); if (param.get_size()>5 && param.get_elem(5)->get_type()!=Module_Param::MP_NotUsed) cSGInfoReportingAction().set_param(*param.get_elem(5)); if (param.get_size()>6 && param.get_elem(6)->get_type()!=Module_Param::MP_NotUsed) private__extension__gtpc().set_param(*param.get_elem(6)); break; case Module_Param::MP_Assignment_List: { Vector value_used(param.get_size()); value_used.resize(param.get_size(), FALSE); for (size_t val_idx=0; val_idxget_id()->get_name(), "cause")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { cause().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "imsi")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { imsi().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "linkedNSAPI")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { linkedNSAPI().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "imeisv_gtpc")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { imeisv__gtpc().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "mS_InfoChangeReportingAction")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { mS__InfoChangeReportingAction().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "cSGInfoReportingAction")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { cSGInfoReportingAction().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "private_extension_gtpc")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { private__extension__gtpc().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxerror("Non existent field name in type @GTPC_Types.MS_InfoChangeNotificationResponse: %s", curr_param->get_id()->get_name()); break; } } break; default: param.type_error("record value", "@GTPC_Types.MS_InfoChangeNotificationResponse"); } } void MS__InfoChangeNotificationResponse::encode_text(Text_Buf& text_buf) const { field_cause.encode_text(text_buf); field_imsi.encode_text(text_buf); field_linkedNSAPI.encode_text(text_buf); field_imeisv__gtpc.encode_text(text_buf); field_mS__InfoChangeReportingAction.encode_text(text_buf); field_cSGInfoReportingAction.encode_text(text_buf); field_private__extension__gtpc.encode_text(text_buf); } void MS__InfoChangeNotificationResponse::decode_text(Text_Buf& text_buf) { field_cause.decode_text(text_buf); field_imsi.decode_text(text_buf); field_linkedNSAPI.decode_text(text_buf); field_imeisv__gtpc.decode_text(text_buf); field_mS__InfoChangeReportingAction.decode_text(text_buf); field_cSGInfoReportingAction.decode_text(text_buf); field_private__extension__gtpc.decode_text(text_buf); } void MS__InfoChangeNotificationResponse::encode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) const { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-encoding type '%s': ", p_td.name); unsigned BER_coding=va_arg(pvar, unsigned); BER_encode_chk_coding(BER_coding); ASN_BER_TLV_t *tlv=BER_encode_TLV(p_td, BER_coding); tlv->put_in_buffer(p_buf); ASN_BER_TLV_t::destruct(tlv); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-encoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); RAW_enc_tr_pos rp; rp.level=0; rp.pos=NULL; RAW_enc_tree root(FALSE, NULL, &rp, 1, p_td.raw); RAW_encode(p_td, root); root.put_to_buf(p_buf); break;} case TTCN_EncDec::CT_TEXT: { TTCN_EncDec_ErrorContext ec("While TEXT-encoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); TEXT_encode(p_td,p_buf); break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-encoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XER_encode(*(p_td.xer),p_buf, XER_coding, 0, 0, 0); p_buf.put_c('\n'); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-encoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok(va_arg(pvar, int) != 0); JSON_encode(p_td, tok, FALSE); p_buf.put_s(tok.get_buffer_length(), (const unsigned char*)tok.get_buffer()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-encoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_encode(p_td, p_buf); break;} default: TTCN_error("Unknown coding method requested to encode type '%s'", p_td.name); } va_end(pvar); } void MS__InfoChangeNotificationResponse::decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-decoding type '%s': ", p_td.name); unsigned L_form=va_arg(pvar, unsigned); ASN_BER_TLV_t tlv; BER_decode_str2TLV(p_buf, tlv, L_form); BER_decode_TLV(p_td, tlv, L_form); if(tlv.isComplete) p_buf.increase_pos(tlv.get_len()); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-decoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); raw_order_t r_order; switch(p_td.raw->top_bit_order) { case TOP_BIT_LEFT: r_order=ORDER_LSB; break; case TOP_BIT_RIGHT: default: r_order=ORDER_MSB; } int rawr = RAW_decode(p_td, p_buf, p_buf.get_len()*8, r_order); if(rawr<0) switch (-rawr) { case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: ec.error((TTCN_EncDec::error_type_t)-rawr, "Can not decode type '%s', because incomplete message was received", p_td.name); break; case 1: default: ec.error(TTCN_EncDec::ET_INVAL_MSG, "Can not decode type '%s', because invalid message was received", p_td.name); break; } break;} case TTCN_EncDec::CT_TEXT: { Limit_Token_List limit; TTCN_EncDec_ErrorContext ec("While TEXT-decoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); const unsigned char *b_data=p_buf.get_data(); int null_added=0; if(b_data[p_buf.get_len()-1]!='\0'){ null_added=1; p_buf.set_pos(p_buf.get_len()); p_buf.put_zero(8,ORDER_LSB); p_buf.rewind(); } if(TEXT_decode(p_td,p_buf,limit)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); if(null_added){ size_t actpos=p_buf.get_pos(); p_buf.set_pos(p_buf.get_len()-1); p_buf.cut_end(); p_buf.set_pos(actpos); } break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-decoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XmlReaderWrap reader(p_buf); for (int rd_ok=reader.Read(); rd_ok==1; rd_ok=reader.Read()) { if (reader.NodeType() == XML_READER_TYPE_ELEMENT) break; } XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL, XER_NONE, 0); size_t bytes = reader.ByteConsumed(); p_buf.set_pos(bytes); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-decoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok((const char*)p_buf.get_data(), p_buf.get_len()); if(JSON_decode(p_td, tok, FALSE, FALSE)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); p_buf.set_pos(tok.get_buf_pos()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-decoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_struct p_oer; OER_decode(p_td, p_buf, p_oer); break;} default: TTCN_error("Unknown coding method requested to decode type '%s'", p_td.name); } va_end(pvar); } int MS__InfoChangeNotificationResponse::RAW_decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int limit, raw_order_t top_bit_ord, boolean no_err, int, boolean, const RAW_Force_Omit* force_omit) { (void)no_err; int prepaddlength=p_buf.increase_pos_padd(p_td.raw->prepadding); limit-=prepaddlength; size_t last_decoded_pos = p_buf.get_pos_bit(); int decoded_length = 0; int decoded_field_length = 0; raw_order_t local_top_order; if(p_td.raw->top_bit_order==TOP_BIT_INHERITED)local_top_order=top_bit_ord; else if(p_td.raw->top_bit_order==TOP_BIT_RIGHT)local_top_order=ORDER_MSB; else local_top_order=ORDER_LSB; RAW_Force_Omit field_0_force_omit(0, force_omit, Cause__gtpc_descr_.raw->forceomit); decoded_field_length = field_cause.RAW_decode(Cause__gtpc_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_0_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); if (limit > 0){ if (force_omit != NULL && (*force_omit)(1)) { field_imsi = OMIT_VALUE; } else { size_t fl_start_pos = p_buf.get_pos_bit(); RAW_Force_Omit field_1_force_omit(1, force_omit, IMSI__gtpc_descr_.raw->forceomit); decoded_field_length = field_imsi().RAW_decode(IMSI__gtpc_descr_, p_buf, limit, local_top_order, TRUE, -1, TRUE, &field_1_force_omit); if (decoded_field_length < 1) { field_imsi = OMIT_VALUE; p_buf.set_pos_bit(fl_start_pos); } else { decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); } } } else field_imsi=OMIT_VALUE; if (limit > 0){ if (force_omit != NULL && (*force_omit)(2)) { field_linkedNSAPI = OMIT_VALUE; } else { size_t fl_start_pos = p_buf.get_pos_bit(); RAW_Force_Omit field_2_force_omit(2, force_omit, NSAPI__GTPC_descr_.raw->forceomit); decoded_field_length = field_linkedNSAPI().RAW_decode(NSAPI__GTPC_descr_, p_buf, limit, local_top_order, TRUE, -1, TRUE, &field_2_force_omit); if (decoded_field_length < 1) { field_linkedNSAPI = OMIT_VALUE; p_buf.set_pos_bit(fl_start_pos); } else { decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); } } } else field_linkedNSAPI=OMIT_VALUE; if (limit > 0){ if (force_omit != NULL && (*force_omit)(3)) { field_imeisv__gtpc = OMIT_VALUE; } else { size_t fl_start_pos = p_buf.get_pos_bit(); RAW_Force_Omit field_3_force_omit(3, force_omit, IMEISV__gtpc_descr_.raw->forceomit); decoded_field_length = field_imeisv__gtpc().RAW_decode(IMEISV__gtpc_descr_, p_buf, limit, local_top_order, TRUE, -1, TRUE, &field_3_force_omit); if (decoded_field_length < 1) { field_imeisv__gtpc = OMIT_VALUE; p_buf.set_pos_bit(fl_start_pos); } else { decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); } } } else field_imeisv__gtpc=OMIT_VALUE; if (limit > 0){ if (force_omit != NULL && (*force_omit)(4)) { field_mS__InfoChangeReportingAction = OMIT_VALUE; } else { size_t fl_start_pos = p_buf.get_pos_bit(); RAW_Force_Omit field_4_force_omit(4, force_omit, MS__InfoChangeReportingAction_descr_.raw->forceomit); decoded_field_length = field_mS__InfoChangeReportingAction().RAW_decode(MS__InfoChangeReportingAction_descr_, p_buf, limit, local_top_order, TRUE, -1, TRUE, &field_4_force_omit); if (decoded_field_length < 1) { field_mS__InfoChangeReportingAction = OMIT_VALUE; p_buf.set_pos_bit(fl_start_pos); } else { decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); } } } else field_mS__InfoChangeReportingAction=OMIT_VALUE; if (limit > 0){ if (force_omit != NULL && (*force_omit)(5)) { field_cSGInfoReportingAction = OMIT_VALUE; } else { size_t fl_start_pos = p_buf.get_pos_bit(); RAW_Force_Omit field_5_force_omit(5, force_omit, CSGInfoReportingAction_descr_.raw->forceomit); decoded_field_length = field_cSGInfoReportingAction().RAW_decode(CSGInfoReportingAction_descr_, p_buf, limit, local_top_order, TRUE, -1, TRUE, &field_5_force_omit); if (decoded_field_length < 1) { field_cSGInfoReportingAction = OMIT_VALUE; p_buf.set_pos_bit(fl_start_pos); } else { decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); } } } else field_cSGInfoReportingAction=OMIT_VALUE; if (limit > 0){ if (force_omit != NULL && (*force_omit)(6)) { field_private__extension__gtpc = OMIT_VALUE; } else { size_t fl_start_pos = p_buf.get_pos_bit(); RAW_Force_Omit field_6_force_omit(6, force_omit, PrivateExtension__gtpc__List_descr_.raw->forceomit); decoded_field_length = field_private__extension__gtpc().RAW_decode(PrivateExtension__gtpc__List_descr_, p_buf, limit, local_top_order, TRUE, -1, TRUE, &field_6_force_omit); if (decoded_field_length < 1) { field_private__extension__gtpc = OMIT_VALUE; p_buf.set_pos_bit(fl_start_pos); } else { decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); } } } else field_private__extension__gtpc=OMIT_VALUE; p_buf.set_pos_bit(last_decoded_pos); return decoded_length+prepaddlength+p_buf.increase_pos_padd(p_td.raw->padding); } int MS__InfoChangeNotificationResponse::RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree& myleaf) const { if (!is_bound()) TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_UNBOUND, "Encoding an unbound value."); int encoded_length = 0; myleaf.isleaf = FALSE; myleaf.body.node.num_of_nodes = 7; myleaf.body.node.nodes = init_nodes_of_enc_tree(7); myleaf.body.node.nodes[0] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 0, Cause__gtpc_descr_.raw); if (field_imsi.ispresent()) { myleaf.body.node.nodes[1] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 1, IMSI__gtpc_descr_.raw); } else myleaf.body.node.nodes[1] = NULL; if (field_linkedNSAPI.ispresent()) { myleaf.body.node.nodes[2] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 2, NSAPI__GTPC_descr_.raw); } else myleaf.body.node.nodes[2] = NULL; if (field_imeisv__gtpc.ispresent()) { myleaf.body.node.nodes[3] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 3, IMEISV__gtpc_descr_.raw); } else myleaf.body.node.nodes[3] = NULL; if (field_mS__InfoChangeReportingAction.ispresent()) { myleaf.body.node.nodes[4] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 4, MS__InfoChangeReportingAction_descr_.raw); } else myleaf.body.node.nodes[4] = NULL; if (field_cSGInfoReportingAction.ispresent()) { myleaf.body.node.nodes[5] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 5, CSGInfoReportingAction_descr_.raw); } else myleaf.body.node.nodes[5] = NULL; if (field_private__extension__gtpc.ispresent()) { myleaf.body.node.nodes[6] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 6, PrivateExtension__gtpc__List_descr_.raw); } else myleaf.body.node.nodes[6] = NULL; encoded_length += field_cause.RAW_encode(Cause__gtpc_descr_, *myleaf.body.node.nodes[0]); if (field_imsi.ispresent()) { encoded_length += field_imsi().RAW_encode(IMSI__gtpc_descr_, *myleaf.body.node.nodes[1]); } if (field_linkedNSAPI.ispresent()) { encoded_length += field_linkedNSAPI().RAW_encode(NSAPI__GTPC_descr_, *myleaf.body.node.nodes[2]); } if (field_imeisv__gtpc.ispresent()) { encoded_length += field_imeisv__gtpc().RAW_encode(IMEISV__gtpc_descr_, *myleaf.body.node.nodes[3]); } if (field_mS__InfoChangeReportingAction.ispresent()) { encoded_length += field_mS__InfoChangeReportingAction().RAW_encode(MS__InfoChangeReportingAction_descr_, *myleaf.body.node.nodes[4]); } if (field_cSGInfoReportingAction.ispresent()) { encoded_length += field_cSGInfoReportingAction().RAW_encode(CSGInfoReportingAction_descr_, *myleaf.body.node.nodes[5]); } if (field_private__extension__gtpc.ispresent()) { encoded_length += field_private__extension__gtpc().RAW_encode(PrivateExtension__gtpc__List_descr_, *myleaf.body.node.nodes[6]); } return myleaf.length = encoded_length; } struct MS__InfoChangeNotificationResponse_template::single_value_struct { Cause__gtpc_template field_cause; IMSI__gtpc_template field_imsi; NSAPI__GTPC_template field_linkedNSAPI; IMEISV__gtpc_template field_imeisv__gtpc; MS__InfoChangeReportingAction_template field_mS__InfoChangeReportingAction; CSGInfoReportingAction_template field_cSGInfoReportingAction; PrivateExtension__gtpc__List_template field_private__extension__gtpc; }; void MS__InfoChangeNotificationResponse_template::set_specific() { if (template_selection != SPECIFIC_VALUE) { template_sel old_selection = template_selection; clean_up(); single_value = new single_value_struct; set_selection(SPECIFIC_VALUE); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) { single_value->field_cause = ANY_VALUE; single_value->field_imsi = ANY_OR_OMIT; single_value->field_linkedNSAPI = ANY_OR_OMIT; single_value->field_imeisv__gtpc = ANY_OR_OMIT; single_value->field_mS__InfoChangeReportingAction = ANY_OR_OMIT; single_value->field_cSGInfoReportingAction = ANY_OR_OMIT; single_value->field_private__extension__gtpc = ANY_OR_OMIT; } } } void MS__InfoChangeNotificationResponse_template::copy_value(const MS__InfoChangeNotificationResponse& other_value) { single_value = new single_value_struct; if (other_value.cause().is_bound()) { single_value->field_cause = other_value.cause(); } else { single_value->field_cause.clean_up(); } if (other_value.imsi().is_bound()) { if (other_value.imsi().ispresent()) single_value->field_imsi = other_value.imsi()(); else single_value->field_imsi = OMIT_VALUE; } else { single_value->field_imsi.clean_up(); } if (other_value.linkedNSAPI().is_bound()) { if (other_value.linkedNSAPI().ispresent()) single_value->field_linkedNSAPI = other_value.linkedNSAPI()(); else single_value->field_linkedNSAPI = OMIT_VALUE; } else { single_value->field_linkedNSAPI.clean_up(); } if (other_value.imeisv__gtpc().is_bound()) { if (other_value.imeisv__gtpc().ispresent()) single_value->field_imeisv__gtpc = other_value.imeisv__gtpc()(); else single_value->field_imeisv__gtpc = OMIT_VALUE; } else { single_value->field_imeisv__gtpc.clean_up(); } if (other_value.mS__InfoChangeReportingAction().is_bound()) { if (other_value.mS__InfoChangeReportingAction().ispresent()) single_value->field_mS__InfoChangeReportingAction = other_value.mS__InfoChangeReportingAction()(); else single_value->field_mS__InfoChangeReportingAction = OMIT_VALUE; } else { single_value->field_mS__InfoChangeReportingAction.clean_up(); } if (other_value.cSGInfoReportingAction().is_bound()) { if (other_value.cSGInfoReportingAction().ispresent()) single_value->field_cSGInfoReportingAction = other_value.cSGInfoReportingAction()(); else single_value->field_cSGInfoReportingAction = OMIT_VALUE; } else { single_value->field_cSGInfoReportingAction.clean_up(); } if (other_value.private__extension__gtpc().is_bound()) { if (other_value.private__extension__gtpc().ispresent()) single_value->field_private__extension__gtpc = other_value.private__extension__gtpc()(); else single_value->field_private__extension__gtpc = OMIT_VALUE; } else { single_value->field_private__extension__gtpc.clean_up(); } set_selection(SPECIFIC_VALUE); } void MS__InfoChangeNotificationResponse_template::copy_template(const MS__InfoChangeNotificationResponse_template& other_value) { switch (other_value.template_selection) { case SPECIFIC_VALUE: single_value = new single_value_struct; if (UNINITIALIZED_TEMPLATE != other_value.cause().get_selection()) { single_value->field_cause = other_value.cause(); } else { single_value->field_cause.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.imsi().get_selection()) { single_value->field_imsi = other_value.imsi(); } else { single_value->field_imsi.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.linkedNSAPI().get_selection()) { single_value->field_linkedNSAPI = other_value.linkedNSAPI(); } else { single_value->field_linkedNSAPI.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.imeisv__gtpc().get_selection()) { single_value->field_imeisv__gtpc = other_value.imeisv__gtpc(); } else { single_value->field_imeisv__gtpc.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.mS__InfoChangeReportingAction().get_selection()) { single_value->field_mS__InfoChangeReportingAction = other_value.mS__InfoChangeReportingAction(); } else { single_value->field_mS__InfoChangeReportingAction.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.cSGInfoReportingAction().get_selection()) { single_value->field_cSGInfoReportingAction = other_value.cSGInfoReportingAction(); } else { single_value->field_cSGInfoReportingAction.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.private__extension__gtpc().get_selection()) { single_value->field_private__extension__gtpc = other_value.private__extension__gtpc(); } else { single_value->field_private__extension__gtpc.clean_up(); } case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: value_list.n_values = other_value.value_list.n_values; value_list.list_value = new MS__InfoChangeNotificationResponse_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]); break; case IMPLICATION_MATCH: implication_.precondition = new MS__InfoChangeNotificationResponse_template(*other_value.implication_.precondition); implication_.implied_template = new MS__InfoChangeNotificationResponse_template(*other_value.implication_.implied_template); break; case DYNAMIC_MATCH: dyn_match = other_value.dyn_match; dyn_match->ref_count++; break; default: TTCN_error("Copying an uninitialized/unsupported template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); break; } set_selection(other_value); } MS__InfoChangeNotificationResponse_template::MS__InfoChangeNotificationResponse_template() { } MS__InfoChangeNotificationResponse_template::MS__InfoChangeNotificationResponse_template(template_sel other_value) : Base_Template(other_value) { check_single_selection(other_value); } MS__InfoChangeNotificationResponse_template::MS__InfoChangeNotificationResponse_template(const MS__InfoChangeNotificationResponse& other_value) { copy_value(other_value); } MS__InfoChangeNotificationResponse_template::MS__InfoChangeNotificationResponse_template(const OPTIONAL& other_value) { switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const MS__InfoChangeNotificationResponse&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Creating a template of type @GTPC_Types.MS_InfoChangeNotificationResponse from an unbound optional field."); } } MS__InfoChangeNotificationResponse_template::MS__InfoChangeNotificationResponse_template(MS__InfoChangeNotificationResponse_template* p_precondition, MS__InfoChangeNotificationResponse_template* p_implied_template) : Base_Template(IMPLICATION_MATCH) { implication_.precondition = p_precondition; implication_.implied_template = p_implied_template; } MS__InfoChangeNotificationResponse_template::MS__InfoChangeNotificationResponse_template(Dynamic_Match_Interface* p_dyn_match) : Base_Template(DYNAMIC_MATCH) { dyn_match = new dynmatch_struct; dyn_match->ptr = p_dyn_match; dyn_match->ref_count = 1; } MS__InfoChangeNotificationResponse_template::MS__InfoChangeNotificationResponse_template(const MS__InfoChangeNotificationResponse_template& other_value) : Base_Template() { copy_template(other_value); } MS__InfoChangeNotificationResponse_template::~MS__InfoChangeNotificationResponse_template() { clean_up(); } MS__InfoChangeNotificationResponse_template& MS__InfoChangeNotificationResponse_template::operator=(template_sel other_value) { check_single_selection(other_value); clean_up(); set_selection(other_value); return *this; } MS__InfoChangeNotificationResponse_template& MS__InfoChangeNotificationResponse_template::operator=(const MS__InfoChangeNotificationResponse& other_value) { clean_up(); copy_value(other_value); return *this; } MS__InfoChangeNotificationResponse_template& MS__InfoChangeNotificationResponse_template::operator=(const OPTIONAL& other_value) { clean_up(); switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const MS__InfoChangeNotificationResponse&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Assignment of an unbound optional field to a template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); } return *this; } MS__InfoChangeNotificationResponse_template& MS__InfoChangeNotificationResponse_template::operator=(const MS__InfoChangeNotificationResponse_template& other_value) { if (&other_value != this) { clean_up(); copy_template(other_value); } return *this; } boolean MS__InfoChangeNotificationResponse_template::match(const MS__InfoChangeNotificationResponse& other_value, boolean legacy) const { if (!other_value.is_bound()) return FALSE; switch (template_selection) { case ANY_VALUE: case ANY_OR_OMIT: return TRUE; case OMIT_VALUE: return FALSE; case SPECIFIC_VALUE: if(!other_value.cause().is_bound()) return FALSE; if(!single_value->field_cause.match(other_value.cause(), legacy))return FALSE; if(!other_value.imsi().is_bound()) return FALSE; if((other_value.imsi().ispresent() ? !single_value->field_imsi.match((const IMSI__gtpc&)other_value.imsi(), legacy) : !single_value->field_imsi.match_omit(legacy)))return FALSE; if(!other_value.linkedNSAPI().is_bound()) return FALSE; if((other_value.linkedNSAPI().ispresent() ? !single_value->field_linkedNSAPI.match((const NSAPI__GTPC&)other_value.linkedNSAPI(), legacy) : !single_value->field_linkedNSAPI.match_omit(legacy)))return FALSE; if(!other_value.imeisv__gtpc().is_bound()) return FALSE; if((other_value.imeisv__gtpc().ispresent() ? !single_value->field_imeisv__gtpc.match((const IMEISV__gtpc&)other_value.imeisv__gtpc(), legacy) : !single_value->field_imeisv__gtpc.match_omit(legacy)))return FALSE; if(!other_value.mS__InfoChangeReportingAction().is_bound()) return FALSE; if((other_value.mS__InfoChangeReportingAction().ispresent() ? !single_value->field_mS__InfoChangeReportingAction.match((const MS__InfoChangeReportingAction&)other_value.mS__InfoChangeReportingAction(), legacy) : !single_value->field_mS__InfoChangeReportingAction.match_omit(legacy)))return FALSE; if(!other_value.cSGInfoReportingAction().is_bound()) return FALSE; if((other_value.cSGInfoReportingAction().ispresent() ? !single_value->field_cSGInfoReportingAction.match((const CSGInfoReportingAction&)other_value.cSGInfoReportingAction(), legacy) : !single_value->field_cSGInfoReportingAction.match_omit(legacy)))return FALSE; if(!other_value.private__extension__gtpc().is_bound()) return FALSE; if((other_value.private__extension__gtpc().ispresent() ? !single_value->field_private__extension__gtpc.match((const PrivateExtension__gtpc__List&)other_value.private__extension__gtpc(), legacy) : !single_value->field_private__extension__gtpc.match_omit(legacy)))return FALSE; return TRUE; case VALUE_LIST: case COMPLEMENTED_LIST: for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) if (value_list.list_value[list_count].match(other_value, legacy)) return template_selection == VALUE_LIST; return template_selection == COMPLEMENTED_LIST; case CONJUNCTION_MATCH: for (unsigned int i = 0; i < value_list.n_values; i++) { if (!value_list.list_value[i].match(other_value)) { return FALSE; } } return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value); case DYNAMIC_MATCH: return dyn_match->ptr->match(other_value); default: TTCN_error("Matching an uninitialized/unsupported template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); } return FALSE; } boolean MS__InfoChangeNotificationResponse_template::is_bound() const { if (template_selection == UNINITIALIZED_TEMPLATE && !is_ifpresent) return FALSE; if (template_selection != SPECIFIC_VALUE) return TRUE; return single_value->field_cause.is_bound() || (single_value->field_imsi.is_omit() || single_value->field_imsi.is_bound()) || (single_value->field_linkedNSAPI.is_omit() || single_value->field_linkedNSAPI.is_bound()) || (single_value->field_imeisv__gtpc.is_omit() || single_value->field_imeisv__gtpc.is_bound()) || (single_value->field_mS__InfoChangeReportingAction.is_omit() || single_value->field_mS__InfoChangeReportingAction.is_bound()) || (single_value->field_cSGInfoReportingAction.is_omit() || single_value->field_cSGInfoReportingAction.is_bound()) || (single_value->field_private__extension__gtpc.is_omit() || single_value->field_private__extension__gtpc.is_bound()); } boolean MS__InfoChangeNotificationResponse_template::is_value() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE; return single_value->field_cause.is_value() && (single_value->field_imsi.is_omit() || single_value->field_imsi.is_value()) && (single_value->field_linkedNSAPI.is_omit() || single_value->field_linkedNSAPI.is_value()) && (single_value->field_imeisv__gtpc.is_omit() || single_value->field_imeisv__gtpc.is_value()) && (single_value->field_mS__InfoChangeReportingAction.is_omit() || single_value->field_mS__InfoChangeReportingAction.is_value()) && (single_value->field_cSGInfoReportingAction.is_omit() || single_value->field_cSGInfoReportingAction.is_value()) && (single_value->field_private__extension__gtpc.is_omit() || single_value->field_private__extension__gtpc.is_value()); } void MS__InfoChangeNotificationResponse_template::clean_up() { switch (template_selection) { case SPECIFIC_VALUE: delete single_value; break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: delete [] value_list.list_value; break; case IMPLICATION_MATCH: delete implication_.precondition; delete implication_.implied_template; break; case DYNAMIC_MATCH: dyn_match->ref_count--; if (dyn_match->ref_count == 0) { delete dyn_match->ptr; delete dyn_match; } break; default: break; } template_selection = UNINITIALIZED_TEMPLATE; } MS__InfoChangeNotificationResponse MS__InfoChangeNotificationResponse_template::valueof() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); MS__InfoChangeNotificationResponse ret_val; if (single_value->field_cause.is_bound()) { ret_val.cause() = single_value->field_cause.valueof(); } if (single_value->field_imsi.is_omit()) ret_val.imsi() = OMIT_VALUE; else if (single_value->field_imsi.is_bound()) { ret_val.imsi() = single_value->field_imsi.valueof(); } if (single_value->field_linkedNSAPI.is_omit()) ret_val.linkedNSAPI() = OMIT_VALUE; else if (single_value->field_linkedNSAPI.is_bound()) { ret_val.linkedNSAPI() = single_value->field_linkedNSAPI.valueof(); } if (single_value->field_imeisv__gtpc.is_omit()) ret_val.imeisv__gtpc() = OMIT_VALUE; else if (single_value->field_imeisv__gtpc.is_bound()) { ret_val.imeisv__gtpc() = single_value->field_imeisv__gtpc.valueof(); } if (single_value->field_mS__InfoChangeReportingAction.is_omit()) ret_val.mS__InfoChangeReportingAction() = OMIT_VALUE; else if (single_value->field_mS__InfoChangeReportingAction.is_bound()) { ret_val.mS__InfoChangeReportingAction() = single_value->field_mS__InfoChangeReportingAction.valueof(); } if (single_value->field_cSGInfoReportingAction.is_omit()) ret_val.cSGInfoReportingAction() = OMIT_VALUE; else if (single_value->field_cSGInfoReportingAction.is_bound()) { ret_val.cSGInfoReportingAction() = single_value->field_cSGInfoReportingAction.valueof(); } if (single_value->field_private__extension__gtpc.is_omit()) ret_val.private__extension__gtpc() = OMIT_VALUE; else if (single_value->field_private__extension__gtpc.is_bound()) { ret_val.private__extension__gtpc() = single_value->field_private__extension__gtpc.valueof(); } return ret_val; } void MS__InfoChangeNotificationResponse_template::set_type(template_sel template_type, unsigned int list_length) { if (template_type != VALUE_LIST && template_type != COMPLEMENTED_LIST&& template_type != CONJUNCTION_MATCH) TTCN_error("Setting an invalid list for a template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); clean_up(); set_selection(template_type); value_list.n_values = list_length; value_list.list_value = new MS__InfoChangeNotificationResponse_template[list_length]; } MS__InfoChangeNotificationResponse_template& MS__InfoChangeNotificationResponse_template::list_item(unsigned int list_index) const { if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST&& template_selection != CONJUNCTION_MATCH) TTCN_error("Accessing a list element of a non-list template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); if (list_index >= value_list.n_values) TTCN_error("Index overflow in a value list template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); return value_list.list_value[list_index]; } Cause__gtpc_template& MS__InfoChangeNotificationResponse_template::cause() { set_specific(); return single_value->field_cause; } const Cause__gtpc_template& MS__InfoChangeNotificationResponse_template::cause() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field cause of a non-specific template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); return single_value->field_cause; } IMSI__gtpc_template& MS__InfoChangeNotificationResponse_template::imsi() { set_specific(); return single_value->field_imsi; } const IMSI__gtpc_template& MS__InfoChangeNotificationResponse_template::imsi() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field imsi of a non-specific template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); return single_value->field_imsi; } NSAPI__GTPC_template& MS__InfoChangeNotificationResponse_template::linkedNSAPI() { set_specific(); return single_value->field_linkedNSAPI; } const NSAPI__GTPC_template& MS__InfoChangeNotificationResponse_template::linkedNSAPI() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field linkedNSAPI of a non-specific template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); return single_value->field_linkedNSAPI; } IMEISV__gtpc_template& MS__InfoChangeNotificationResponse_template::imeisv__gtpc() { set_specific(); return single_value->field_imeisv__gtpc; } const IMEISV__gtpc_template& MS__InfoChangeNotificationResponse_template::imeisv__gtpc() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field imeisv_gtpc of a non-specific template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); return single_value->field_imeisv__gtpc; } MS__InfoChangeReportingAction_template& MS__InfoChangeNotificationResponse_template::mS__InfoChangeReportingAction() { set_specific(); return single_value->field_mS__InfoChangeReportingAction; } const MS__InfoChangeReportingAction_template& MS__InfoChangeNotificationResponse_template::mS__InfoChangeReportingAction() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mS_InfoChangeReportingAction of a non-specific template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); return single_value->field_mS__InfoChangeReportingAction; } CSGInfoReportingAction_template& MS__InfoChangeNotificationResponse_template::cSGInfoReportingAction() { set_specific(); return single_value->field_cSGInfoReportingAction; } const CSGInfoReportingAction_template& MS__InfoChangeNotificationResponse_template::cSGInfoReportingAction() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field cSGInfoReportingAction of a non-specific template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); return single_value->field_cSGInfoReportingAction; } PrivateExtension__gtpc__List_template& MS__InfoChangeNotificationResponse_template::private__extension__gtpc() { set_specific(); return single_value->field_private__extension__gtpc; } const PrivateExtension__gtpc__List_template& MS__InfoChangeNotificationResponse_template::private__extension__gtpc() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field private_extension_gtpc of a non-specific template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); return single_value->field_private__extension__gtpc; } int MS__InfoChangeNotificationResponse_template::size_of() const { if (is_ifpresent) TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.MS_InfoChangeNotificationResponse which has an ifpresent attribute."); switch (template_selection) { case SPECIFIC_VALUE: { int ret_val = 1; if (single_value->field_imsi.is_present()) ret_val++; if (single_value->field_linkedNSAPI.is_present()) ret_val++; if (single_value->field_imeisv__gtpc.is_present()) ret_val++; if (single_value->field_mS__InfoChangeReportingAction.is_present()) ret_val++; if (single_value->field_cSGInfoReportingAction.is_present()) ret_val++; if (single_value->field_private__extension__gtpc.is_present()) ret_val++; return ret_val; } case VALUE_LIST: { if (value_list.n_values<1) TTCN_error("Internal error: Performing sizeof() operation on a template of type @GTPC_Types.MS_InfoChangeNotificationResponse containing an empty list."); int item_size = value_list.list_value[0].size_of(); for (unsigned int l_idx = 1; l_idx < value_list.n_values; l_idx++) { if (value_list.list_value[l_idx].size_of()!=item_size) TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.MS_InfoChangeNotificationResponse containing a value list with different sizes."); } return item_size; } case OMIT_VALUE: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.MS_InfoChangeNotificationResponse containing omit value."); case ANY_VALUE: case ANY_OR_OMIT: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.MS_InfoChangeNotificationResponse containing */? value."); case COMPLEMENTED_LIST: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.MS_InfoChangeNotificationResponse containing complemented list."); case CONJUNCTION_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.MS_InfoChangeNotificationResponse containing a conjunction list match."); case IMPLICATION_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.MS_InfoChangeNotificationResponse containing an implication match."); case DYNAMIC_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.MS_InfoChangeNotificationResponse containing a dynamic match."); default: TTCN_error("Performing sizeof() operation on an uninitialized/unsupported template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); } return 0; } void MS__InfoChangeNotificationResponse_template::log() const { switch (template_selection) { case SPECIFIC_VALUE: TTCN_Logger::log_event_str("{ cause := "); single_value->field_cause.log(); TTCN_Logger::log_event_str(", imsi := "); single_value->field_imsi.log(); TTCN_Logger::log_event_str(", linkedNSAPI := "); single_value->field_linkedNSAPI.log(); TTCN_Logger::log_event_str(", imeisv_gtpc := "); single_value->field_imeisv__gtpc.log(); TTCN_Logger::log_event_str(", mS_InfoChangeReportingAction := "); single_value->field_mS__InfoChangeReportingAction.log(); TTCN_Logger::log_event_str(", cSGInfoReportingAction := "); single_value->field_cSGInfoReportingAction.log(); TTCN_Logger::log_event_str(", private_extension_gtpc := "); single_value->field_private__extension__gtpc.log(); TTCN_Logger::log_event_str(" }"); break; case COMPLEMENTED_LIST: TTCN_Logger::log_event_str("complement"); case CONJUNCTION_MATCH: if (template_selection == CONJUNCTION_MATCH) { TTCN_Logger::log_event_str("conjunct"); } case VALUE_LIST: TTCN_Logger::log_char('('); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) { if (list_count > 0) TTCN_Logger::log_event_str(", "); value_list.list_value[list_count].log(); } TTCN_Logger::log_char(')'); break; case IMPLICATION_MATCH: implication_.precondition->log(); TTCN_Logger::log_event_str(" implies "); implication_.implied_template->log(); break; case DYNAMIC_MATCH: TTCN_Logger::log_event_str("@dynamic template"); break; default: log_generic(); } log_ifpresent(); } void MS__InfoChangeNotificationResponse_template::log_match(const MS__InfoChangeNotificationResponse& match_value, boolean legacy) const { if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ if(match(match_value, legacy)){ TTCN_Logger::print_logmatch_buffer(); TTCN_Logger::log_event_str(" matched"); } else{ if (template_selection == SPECIFIC_VALUE) { size_t previous_size = TTCN_Logger::get_logmatch_buffer_len(); if(!single_value->field_cause.match(match_value.cause(), legacy)){ TTCN_Logger::log_logmatch_info(".cause"); single_value->field_cause.log_match(match_value.cause(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if (match_value.imsi().ispresent()){ if(!single_value->field_imsi.match(match_value.imsi(), legacy)){ TTCN_Logger::log_logmatch_info(".imsi"); single_value->field_imsi.log_match(match_value.imsi(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } else { if (!single_value->field_imsi.match_omit(legacy)){ TTCN_Logger::log_logmatch_info(".imsi := omit with "); TTCN_Logger::print_logmatch_buffer(); single_value->field_imsi.log(); TTCN_Logger::log_event_str(" unmatched"); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } if (match_value.linkedNSAPI().ispresent()){ if(!single_value->field_linkedNSAPI.match(match_value.linkedNSAPI(), legacy)){ TTCN_Logger::log_logmatch_info(".linkedNSAPI"); single_value->field_linkedNSAPI.log_match(match_value.linkedNSAPI(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } else { if (!single_value->field_linkedNSAPI.match_omit(legacy)){ TTCN_Logger::log_logmatch_info(".linkedNSAPI := omit with "); TTCN_Logger::print_logmatch_buffer(); single_value->field_linkedNSAPI.log(); TTCN_Logger::log_event_str(" unmatched"); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } if (match_value.imeisv__gtpc().ispresent()){ if(!single_value->field_imeisv__gtpc.match(match_value.imeisv__gtpc(), legacy)){ TTCN_Logger::log_logmatch_info(".imeisv_gtpc"); single_value->field_imeisv__gtpc.log_match(match_value.imeisv__gtpc(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } else { if (!single_value->field_imeisv__gtpc.match_omit(legacy)){ TTCN_Logger::log_logmatch_info(".imeisv_gtpc := omit with "); TTCN_Logger::print_logmatch_buffer(); single_value->field_imeisv__gtpc.log(); TTCN_Logger::log_event_str(" unmatched"); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } if (match_value.mS__InfoChangeReportingAction().ispresent()){ if(!single_value->field_mS__InfoChangeReportingAction.match(match_value.mS__InfoChangeReportingAction(), legacy)){ TTCN_Logger::log_logmatch_info(".mS_InfoChangeReportingAction"); single_value->field_mS__InfoChangeReportingAction.log_match(match_value.mS__InfoChangeReportingAction(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } else { if (!single_value->field_mS__InfoChangeReportingAction.match_omit(legacy)){ TTCN_Logger::log_logmatch_info(".mS_InfoChangeReportingAction := omit with "); TTCN_Logger::print_logmatch_buffer(); single_value->field_mS__InfoChangeReportingAction.log(); TTCN_Logger::log_event_str(" unmatched"); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } if (match_value.cSGInfoReportingAction().ispresent()){ if(!single_value->field_cSGInfoReportingAction.match(match_value.cSGInfoReportingAction(), legacy)){ TTCN_Logger::log_logmatch_info(".cSGInfoReportingAction"); single_value->field_cSGInfoReportingAction.log_match(match_value.cSGInfoReportingAction(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } else { if (!single_value->field_cSGInfoReportingAction.match_omit(legacy)){ TTCN_Logger::log_logmatch_info(".cSGInfoReportingAction := omit with "); TTCN_Logger::print_logmatch_buffer(); single_value->field_cSGInfoReportingAction.log(); TTCN_Logger::log_event_str(" unmatched"); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } if (match_value.private__extension__gtpc().ispresent()){ if(!single_value->field_private__extension__gtpc.match(match_value.private__extension__gtpc(), legacy)){ TTCN_Logger::log_logmatch_info(".private_extension_gtpc"); single_value->field_private__extension__gtpc.log_match(match_value.private__extension__gtpc(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } else { if (!single_value->field_private__extension__gtpc.match_omit(legacy)){ TTCN_Logger::log_logmatch_info(".private_extension_gtpc := omit with "); TTCN_Logger::print_logmatch_buffer(); single_value->field_private__extension__gtpc.log(); TTCN_Logger::log_event_str(" unmatched"); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } }else { TTCN_Logger::print_logmatch_buffer(); match_value.log(); TTCN_Logger::log_event_str(" with "); log(); TTCN_Logger::log_event_str(" unmatched"); } } return; } if (template_selection == SPECIFIC_VALUE) { TTCN_Logger::log_event_str("{ cause := "); single_value->field_cause.log_match(match_value.cause(), legacy); TTCN_Logger::log_event_str(", imsi := "); if (match_value.imsi().ispresent()) { single_value->field_imsi.log_match(match_value.imsi(), legacy); } else { TTCN_Logger::log_event_str("omit with "); single_value->field_imsi.log(); if (single_value->field_imsi.match_omit(legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } TTCN_Logger::log_event_str(", linkedNSAPI := "); if (match_value.linkedNSAPI().ispresent()) { single_value->field_linkedNSAPI.log_match(match_value.linkedNSAPI(), legacy); } else { TTCN_Logger::log_event_str("omit with "); single_value->field_linkedNSAPI.log(); if (single_value->field_linkedNSAPI.match_omit(legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } TTCN_Logger::log_event_str(", imeisv_gtpc := "); if (match_value.imeisv__gtpc().ispresent()) { single_value->field_imeisv__gtpc.log_match(match_value.imeisv__gtpc(), legacy); } else { TTCN_Logger::log_event_str("omit with "); single_value->field_imeisv__gtpc.log(); if (single_value->field_imeisv__gtpc.match_omit(legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } TTCN_Logger::log_event_str(", mS_InfoChangeReportingAction := "); if (match_value.mS__InfoChangeReportingAction().ispresent()) { single_value->field_mS__InfoChangeReportingAction.log_match(match_value.mS__InfoChangeReportingAction(), legacy); } else { TTCN_Logger::log_event_str("omit with "); single_value->field_mS__InfoChangeReportingAction.log(); if (single_value->field_mS__InfoChangeReportingAction.match_omit(legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } TTCN_Logger::log_event_str(", cSGInfoReportingAction := "); if (match_value.cSGInfoReportingAction().ispresent()) { single_value->field_cSGInfoReportingAction.log_match(match_value.cSGInfoReportingAction(), legacy); } else { TTCN_Logger::log_event_str("omit with "); single_value->field_cSGInfoReportingAction.log(); if (single_value->field_cSGInfoReportingAction.match_omit(legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } TTCN_Logger::log_event_str(", private_extension_gtpc := "); if (match_value.private__extension__gtpc().ispresent()) { single_value->field_private__extension__gtpc.log_match(match_value.private__extension__gtpc(), legacy); } else { TTCN_Logger::log_event_str("omit with "); single_value->field_private__extension__gtpc.log(); if (single_value->field_private__extension__gtpc.match_omit(legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } TTCN_Logger::log_event_str(" }"); } else { match_value.log(); TTCN_Logger::log_event_str(" with "); log(); if (match(match_value, legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } } void MS__InfoChangeNotificationResponse_template::encode_text(Text_Buf& text_buf) const { encode_text_base(text_buf); switch (template_selection) { case SPECIFIC_VALUE: single_value->field_cause.encode_text(text_buf); single_value->field_imsi.encode_text(text_buf); single_value->field_linkedNSAPI.encode_text(text_buf); single_value->field_imeisv__gtpc.encode_text(text_buf); single_value->field_mS__InfoChangeReportingAction.encode_text(text_buf); single_value->field_cSGInfoReportingAction.encode_text(text_buf); single_value->field_private__extension__gtpc.encode_text(text_buf); case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: text_buf.push_int(value_list.n_values); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].encode_text(text_buf); break; default: TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); } } void MS__InfoChangeNotificationResponse_template::decode_text(Text_Buf& text_buf) { clean_up(); decode_text_base(text_buf); switch (template_selection) { case SPECIFIC_VALUE: single_value = new single_value_struct; single_value->field_cause.decode_text(text_buf); single_value->field_imsi.decode_text(text_buf); single_value->field_linkedNSAPI.decode_text(text_buf); single_value->field_imeisv__gtpc.decode_text(text_buf); single_value->field_mS__InfoChangeReportingAction.decode_text(text_buf); single_value->field_cSGInfoReportingAction.decode_text(text_buf); single_value->field_private__extension__gtpc.decode_text(text_buf); case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: value_list.n_values = text_buf.pull_int().get_val(); value_list.list_value = new MS__InfoChangeNotificationResponse_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].decode_text(text_buf); break; default: TTCN_error("Text decoder: An unknown/unsupported selection was received in a template of type @GTPC_Types.MS_InfoChangeNotificationResponse."); } } void MS__InfoChangeNotificationResponse_template::set_param(Module_Param& param) { param.basic_check(Module_Param::BC_TEMPLATE, "record template"); switch (param.get_type()) { case Module_Param::MP_Omit: *this = OMIT_VALUE; break; case Module_Param::MP_Any: *this = ANY_VALUE; break; case Module_Param::MP_AnyOrNone: *this = ANY_OR_OMIT; break; case Module_Param::MP_List_Template: case Module_Param::MP_ComplementList_Template: case Module_Param::MP_ConjunctList_Template: { MS__InfoChangeNotificationResponse_template new_temp; new_temp.set_type(param.get_type()==Module_Param::MP_List_Template ? VALUE_LIST : (param.get_type() == Module_Param::MP_ConjunctList_Template ? CONJUNCTION_MATCH : COMPLEMENTED_LIST), param.get_size()); for (size_t p_i=0; p_i0 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) cause().set_param(*param.get_elem(0)); if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) imsi().set_param(*param.get_elem(1)); if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) linkedNSAPI().set_param(*param.get_elem(2)); if (param.get_size()>3 && param.get_elem(3)->get_type()!=Module_Param::MP_NotUsed) imeisv__gtpc().set_param(*param.get_elem(3)); if (param.get_size()>4 && param.get_elem(4)->get_type()!=Module_Param::MP_NotUsed) mS__InfoChangeReportingAction().set_param(*param.get_elem(4)); if (param.get_size()>5 && param.get_elem(5)->get_type()!=Module_Param::MP_NotUsed) cSGInfoReportingAction().set_param(*param.get_elem(5)); if (param.get_size()>6 && param.get_elem(6)->get_type()!=Module_Param::MP_NotUsed) private__extension__gtpc().set_param(*param.get_elem(6)); break; case Module_Param::MP_Assignment_List: { Vector value_used(param.get_size()); value_used.resize(param.get_size(), FALSE); for (size_t val_idx=0; val_idxget_id()->get_name(), "cause")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { cause().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "imsi")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { imsi().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "linkedNSAPI")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { linkedNSAPI().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "imeisv_gtpc")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { imeisv__gtpc().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "mS_InfoChangeReportingAction")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { mS__InfoChangeReportingAction().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "cSGInfoReportingAction")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { cSGInfoReportingAction().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "private_extension_gtpc")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { private__extension__gtpc().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxerror("Non existent field name in type @GTPC_Types.MS_InfoChangeNotificationResponse: %s", curr_param->get_id()->get_name()); break; } } break; case Module_Param::MP_Implication_Template: { MS__InfoChangeNotificationResponse_template* precondition = new MS__InfoChangeNotificationResponse_template; precondition->set_param(*param.get_elem(0)); MS__InfoChangeNotificationResponse_template* implied_template = new MS__InfoChangeNotificationResponse_template; implied_template->set_param(*param.get_elem(1)); *this = MS__InfoChangeNotificationResponse_template(precondition, implied_template); } break; default: param.type_error("record template", "@GTPC_Types.MS_InfoChangeNotificationResponse"); } is_ifpresent = param.get_ifpresent(); } void MS__InfoChangeNotificationResponse_template::check_restriction(template_res t_res, const char* t_name, boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return; switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) { case TR_OMIT: if (template_selection==OMIT_VALUE) return; case TR_VALUE: if (template_selection!=SPECIFIC_VALUE || is_ifpresent) break; single_value->field_cause.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.MS_InfoChangeNotificationResponse"); single_value->field_imsi.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.MS_InfoChangeNotificationResponse"); single_value->field_linkedNSAPI.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.MS_InfoChangeNotificationResponse"); single_value->field_imeisv__gtpc.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.MS_InfoChangeNotificationResponse"); single_value->field_mS__InfoChangeReportingAction.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.MS_InfoChangeNotificationResponse"); single_value->field_cSGInfoReportingAction.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.MS_InfoChangeNotificationResponse"); single_value->field_private__extension__gtpc.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.MS_InfoChangeNotificationResponse"); return; case TR_PRESENT: if (!match_omit(legacy)) return; break; default: return; } TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@GTPC_Types.MS_InfoChangeNotificationResponse"); } boolean MS__InfoChangeNotificationResponse_template::is_present(boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE; return !match_omit(legacy); } boolean MS__InfoChangeNotificationResponse_template::match_omit(boolean legacy) const { if (is_ifpresent) return TRUE; switch (template_selection) { case OMIT_VALUE: case ANY_OR_OMIT: return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match_omit() || implication_.implied_template->match_omit(); case VALUE_LIST: case COMPLEMENTED_LIST: if (legacy) { for (unsigned int l_idx=0; l_idxis_value(); case ALT_echoResponse: return field_echoResponse->is_value(); case ALT_versionNotSupported: return field_versionNotSupported->is_value(); case ALT_createPDPContextRequest: return field_createPDPContextRequest->is_value(); case ALT_createPDPContextResponse: return field_createPDPContextResponse->is_value(); case ALT_updatePDPContextRequest: return field_updatePDPContextRequest->is_value(); case ALT_updatePDPContextResponse: return field_updatePDPContextResponse->is_value(); case ALT_deletePDPContextRequest: return field_deletePDPContextRequest->is_value(); case ALT_deletePDPContextResponse: return field_deletePDPContextResponse->is_value(); case ALT_pdu__NotificationRequest: return field_pdu__NotificationRequest->is_value(); case ALT_pdu__NotificationResponse: return field_pdu__NotificationResponse->is_value(); case ALT_pdu__NotificationRejectRequest: return field_pdu__NotificationRejectRequest->is_value(); case ALT_pdu__NotificationRejectResponse: return field_pdu__NotificationRejectResponse->is_value(); case ALT_initiatePDPContextActivationRequest: return field_initiatePDPContextActivationRequest->is_value(); case ALT_initiatePDPContextActivationResponse: return field_initiatePDPContextActivationResponse->is_value(); case ALT_supportedExtensionHeadersNotification: return field_supportedExtensionHeadersNotification->is_value(); case ALT_sendRouteingInformationForGPRSRequest: return field_sendRouteingInformationForGPRSRequest->is_value(); case ALT_sendRouteingInformationForGPRSResponse: return field_sendRouteingInformationForGPRSResponse->is_value(); case ALT_failureReportRequest: return field_failureReportRequest->is_value(); case ALT_failureReportResponse: return field_failureReportResponse->is_value(); case ALT_noteMS__GPRSPresentRequest: return field_noteMS__GPRSPresentRequest->is_value(); case ALT_noteMS__GPRSPresentResponse: return field_noteMS__GPRSPresentResponse->is_value(); case ALT_identificationRequest: return field_identificationRequest->is_value(); case ALT_identificationResponse: return field_identificationResponse->is_value(); case ALT_sgsn__ContextRequest: return field_sgsn__ContextRequest->is_value(); case ALT_sgsn__ContextResponse: return field_sgsn__ContextResponse->is_value(); case ALT_sgsn__ContextAcknowledge: return field_sgsn__ContextAcknowledge->is_value(); case ALT_forwardRelocationRequest: return field_forwardRelocationRequest->is_value(); case ALT_forwardRelocationResponse: return field_forwardRelocationResponse->is_value(); case ALT_forwardRelocationComplete: return field_forwardRelocationComplete->is_value(); case ALT_relocationCancelRequest: return field_relocationCancelRequest->is_value(); case ALT_relocationCancelResponse: return field_relocationCancelResponse->is_value(); case ALT_forwardSRNSContext: return field_forwardSRNSContext->is_value(); case ALT_forwardRelocationCompleteAcknowledge: return field_forwardRelocationCompleteAcknowledge->is_value(); case ALT_forwardSRNSContextAcknowledge: return field_forwardSRNSContextAcknowledge->is_value(); case ALT_uERegistrationQueryRequest: return field_uERegistrationQueryRequest->is_value(); case ALT_uERegistrationQueryResponse: return field_uERegistrationQueryResponse->is_value(); case ALT_ranInformationRelay: return field_ranInformationRelay->is_value(); case ALT_mBMSNotificationRequest: return field_mBMSNotificationRequest->is_value(); case ALT_mBMSNotificationResponse: return field_mBMSNotificationResponse->is_value(); case ALT_mBMSNotificationRejectRequest: return field_mBMSNotificationRejectRequest->is_value(); case ALT_mBMSNotificationRejectResponse: return field_mBMSNotificationRejectResponse->is_value(); case ALT_createMBMSContextRequest: return field_createMBMSContextRequest->is_value(); case ALT_createMBMSContextResponse: return field_createMBMSContextResponse->is_value(); case ALT_updateMBMSContextRequest: return field_updateMBMSContextRequest->is_value(); case ALT_updateMBMSContextResponse: return field_updateMBMSContextResponse->is_value(); case ALT_deleteMBMSContextRequest: return field_deleteMBMSContextRequest->is_value(); case ALT_deleteMBMSContextResponse: return field_deleteMBMSContextResponse->is_value(); case ALT_mBMSRegistrationRequest: return field_mBMSRegistrationRequest->is_value(); case ALT_mBMSRegistrationResponse: return field_mBMSRegistrationResponse->is_value(); case ALT_mBMSDeRegistrationRequest: return field_mBMSDeRegistrationRequest->is_value(); case ALT_mBMSDeRegistrationResponse: return field_mBMSDeRegistrationResponse->is_value(); case ALT_mBMSSessionStartRequest: return field_mBMSSessionStartRequest->is_value(); case ALT_mBMSSessionStartResponse: return field_mBMSSessionStartResponse->is_value(); case ALT_mBMSSessionStopRequest: return field_mBMSSessionStopRequest->is_value(); case ALT_mBMSSessionStopResponse: return field_mBMSSessionStopResponse->is_value(); case ALT_mBMSSessionUpdateRequest: return field_mBMSSessionUpdateRequest->is_value(); case ALT_mBMSSessionUpdateResponse: return field_mBMSSessionUpdateResponse->is_value(); case ALT_mS__InfoChangeNotificationRequest: return field_mS__InfoChangeNotificationRequest->is_value(); case ALT_mS__InfoChangeNotificationResponse: return field_mS__InfoChangeNotificationResponse->is_value(); default: TTCN_error("Invalid selection in union is_bound");} } void GTPC__PDUs::clean_up() { switch (union_selection) { case ALT_echoRequest: delete field_echoRequest; break; case ALT_echoResponse: delete field_echoResponse; break; case ALT_versionNotSupported: delete field_versionNotSupported; break; case ALT_createPDPContextRequest: delete field_createPDPContextRequest; break; case ALT_createPDPContextResponse: delete field_createPDPContextResponse; break; case ALT_updatePDPContextRequest: delete field_updatePDPContextRequest; break; case ALT_updatePDPContextResponse: delete field_updatePDPContextResponse; break; case ALT_deletePDPContextRequest: delete field_deletePDPContextRequest; break; case ALT_deletePDPContextResponse: delete field_deletePDPContextResponse; break; case ALT_pdu__NotificationRequest: delete field_pdu__NotificationRequest; break; case ALT_pdu__NotificationResponse: delete field_pdu__NotificationResponse; break; case ALT_pdu__NotificationRejectRequest: delete field_pdu__NotificationRejectRequest; break; case ALT_pdu__NotificationRejectResponse: delete field_pdu__NotificationRejectResponse; break; case ALT_initiatePDPContextActivationRequest: delete field_initiatePDPContextActivationRequest; break; case ALT_initiatePDPContextActivationResponse: delete field_initiatePDPContextActivationResponse; break; case ALT_supportedExtensionHeadersNotification: delete field_supportedExtensionHeadersNotification; break; case ALT_sendRouteingInformationForGPRSRequest: delete field_sendRouteingInformationForGPRSRequest; break; case ALT_sendRouteingInformationForGPRSResponse: delete field_sendRouteingInformationForGPRSResponse; break; case ALT_failureReportRequest: delete field_failureReportRequest; break; case ALT_failureReportResponse: delete field_failureReportResponse; break; case ALT_noteMS__GPRSPresentRequest: delete field_noteMS__GPRSPresentRequest; break; case ALT_noteMS__GPRSPresentResponse: delete field_noteMS__GPRSPresentResponse; break; case ALT_identificationRequest: delete field_identificationRequest; break; case ALT_identificationResponse: delete field_identificationResponse; break; case ALT_sgsn__ContextRequest: delete field_sgsn__ContextRequest; break; case ALT_sgsn__ContextResponse: delete field_sgsn__ContextResponse; break; case ALT_sgsn__ContextAcknowledge: delete field_sgsn__ContextAcknowledge; break; case ALT_forwardRelocationRequest: delete field_forwardRelocationRequest; break; case ALT_forwardRelocationResponse: delete field_forwardRelocationResponse; break; case ALT_forwardRelocationComplete: delete field_forwardRelocationComplete; break; case ALT_relocationCancelRequest: delete field_relocationCancelRequest; break; case ALT_relocationCancelResponse: delete field_relocationCancelResponse; break; case ALT_forwardSRNSContext: delete field_forwardSRNSContext; break; case ALT_forwardRelocationCompleteAcknowledge: delete field_forwardRelocationCompleteAcknowledge; break; case ALT_forwardSRNSContextAcknowledge: delete field_forwardSRNSContextAcknowledge; break; case ALT_uERegistrationQueryRequest: delete field_uERegistrationQueryRequest; break; case ALT_uERegistrationQueryResponse: delete field_uERegistrationQueryResponse; break; case ALT_ranInformationRelay: delete field_ranInformationRelay; break; case ALT_mBMSNotificationRequest: delete field_mBMSNotificationRequest; break; case ALT_mBMSNotificationResponse: delete field_mBMSNotificationResponse; break; case ALT_mBMSNotificationRejectRequest: delete field_mBMSNotificationRejectRequest; break; case ALT_mBMSNotificationRejectResponse: delete field_mBMSNotificationRejectResponse; break; case ALT_createMBMSContextRequest: delete field_createMBMSContextRequest; break; case ALT_createMBMSContextResponse: delete field_createMBMSContextResponse; break; case ALT_updateMBMSContextRequest: delete field_updateMBMSContextRequest; break; case ALT_updateMBMSContextResponse: delete field_updateMBMSContextResponse; break; case ALT_deleteMBMSContextRequest: delete field_deleteMBMSContextRequest; break; case ALT_deleteMBMSContextResponse: delete field_deleteMBMSContextResponse; break; case ALT_mBMSRegistrationRequest: delete field_mBMSRegistrationRequest; break; case ALT_mBMSRegistrationResponse: delete field_mBMSRegistrationResponse; break; case ALT_mBMSDeRegistrationRequest: delete field_mBMSDeRegistrationRequest; break; case ALT_mBMSDeRegistrationResponse: delete field_mBMSDeRegistrationResponse; break; case ALT_mBMSSessionStartRequest: delete field_mBMSSessionStartRequest; break; case ALT_mBMSSessionStartResponse: delete field_mBMSSessionStartResponse; break; case ALT_mBMSSessionStopRequest: delete field_mBMSSessionStopRequest; break; case ALT_mBMSSessionStopResponse: delete field_mBMSSessionStopResponse; break; case ALT_mBMSSessionUpdateRequest: delete field_mBMSSessionUpdateRequest; break; case ALT_mBMSSessionUpdateResponse: delete field_mBMSSessionUpdateResponse; break; case ALT_mS__InfoChangeNotificationRequest: delete field_mS__InfoChangeNotificationRequest; break; case ALT_mS__InfoChangeNotificationResponse: delete field_mS__InfoChangeNotificationResponse; break; default: break; } union_selection = UNBOUND_VALUE; } void GTPC__PDUs::log() const { switch (union_selection) { case ALT_echoRequest: TTCN_Logger::log_event_str("{ echoRequest := "); field_echoRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_echoResponse: TTCN_Logger::log_event_str("{ echoResponse := "); field_echoResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_versionNotSupported: TTCN_Logger::log_event_str("{ versionNotSupported := "); field_versionNotSupported->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_createPDPContextRequest: TTCN_Logger::log_event_str("{ createPDPContextRequest := "); field_createPDPContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_createPDPContextResponse: TTCN_Logger::log_event_str("{ createPDPContextResponse := "); field_createPDPContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_updatePDPContextRequest: TTCN_Logger::log_event_str("{ updatePDPContextRequest := "); field_updatePDPContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_updatePDPContextResponse: TTCN_Logger::log_event_str("{ updatePDPContextResponse := "); field_updatePDPContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_deletePDPContextRequest: TTCN_Logger::log_event_str("{ deletePDPContextRequest := "); field_deletePDPContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_deletePDPContextResponse: TTCN_Logger::log_event_str("{ deletePDPContextResponse := "); field_deletePDPContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_pdu__NotificationRequest: TTCN_Logger::log_event_str("{ pdu_NotificationRequest := "); field_pdu__NotificationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_pdu__NotificationResponse: TTCN_Logger::log_event_str("{ pdu_NotificationResponse := "); field_pdu__NotificationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_pdu__NotificationRejectRequest: TTCN_Logger::log_event_str("{ pdu_NotificationRejectRequest := "); field_pdu__NotificationRejectRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_pdu__NotificationRejectResponse: TTCN_Logger::log_event_str("{ pdu_NotificationRejectResponse := "); field_pdu__NotificationRejectResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_initiatePDPContextActivationRequest: TTCN_Logger::log_event_str("{ initiatePDPContextActivationRequest := "); field_initiatePDPContextActivationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_initiatePDPContextActivationResponse: TTCN_Logger::log_event_str("{ initiatePDPContextActivationResponse := "); field_initiatePDPContextActivationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_supportedExtensionHeadersNotification: TTCN_Logger::log_event_str("{ supportedExtensionHeadersNotification := "); field_supportedExtensionHeadersNotification->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_sendRouteingInformationForGPRSRequest: TTCN_Logger::log_event_str("{ sendRouteingInformationForGPRSRequest := "); field_sendRouteingInformationForGPRSRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_sendRouteingInformationForGPRSResponse: TTCN_Logger::log_event_str("{ sendRouteingInformationForGPRSResponse := "); field_sendRouteingInformationForGPRSResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_failureReportRequest: TTCN_Logger::log_event_str("{ failureReportRequest := "); field_failureReportRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_failureReportResponse: TTCN_Logger::log_event_str("{ failureReportResponse := "); field_failureReportResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_noteMS__GPRSPresentRequest: TTCN_Logger::log_event_str("{ noteMS_GPRSPresentRequest := "); field_noteMS__GPRSPresentRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_noteMS__GPRSPresentResponse: TTCN_Logger::log_event_str("{ noteMS_GPRSPresentResponse := "); field_noteMS__GPRSPresentResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_identificationRequest: TTCN_Logger::log_event_str("{ identificationRequest := "); field_identificationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_identificationResponse: TTCN_Logger::log_event_str("{ identificationResponse := "); field_identificationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_sgsn__ContextRequest: TTCN_Logger::log_event_str("{ sgsn_ContextRequest := "); field_sgsn__ContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_sgsn__ContextResponse: TTCN_Logger::log_event_str("{ sgsn_ContextResponse := "); field_sgsn__ContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_sgsn__ContextAcknowledge: TTCN_Logger::log_event_str("{ sgsn_ContextAcknowledge := "); field_sgsn__ContextAcknowledge->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_forwardRelocationRequest: TTCN_Logger::log_event_str("{ forwardRelocationRequest := "); field_forwardRelocationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_forwardRelocationResponse: TTCN_Logger::log_event_str("{ forwardRelocationResponse := "); field_forwardRelocationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_forwardRelocationComplete: TTCN_Logger::log_event_str("{ forwardRelocationComplete := "); field_forwardRelocationComplete->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_relocationCancelRequest: TTCN_Logger::log_event_str("{ relocationCancelRequest := "); field_relocationCancelRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_relocationCancelResponse: TTCN_Logger::log_event_str("{ relocationCancelResponse := "); field_relocationCancelResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_forwardSRNSContext: TTCN_Logger::log_event_str("{ forwardSRNSContext := "); field_forwardSRNSContext->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_forwardRelocationCompleteAcknowledge: TTCN_Logger::log_event_str("{ forwardRelocationCompleteAcknowledge := "); field_forwardRelocationCompleteAcknowledge->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_forwardSRNSContextAcknowledge: TTCN_Logger::log_event_str("{ forwardSRNSContextAcknowledge := "); field_forwardSRNSContextAcknowledge->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_uERegistrationQueryRequest: TTCN_Logger::log_event_str("{ uERegistrationQueryRequest := "); field_uERegistrationQueryRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_uERegistrationQueryResponse: TTCN_Logger::log_event_str("{ uERegistrationQueryResponse := "); field_uERegistrationQueryResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_ranInformationRelay: TTCN_Logger::log_event_str("{ ranInformationRelay := "); field_ranInformationRelay->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSNotificationRequest: TTCN_Logger::log_event_str("{ mBMSNotificationRequest := "); field_mBMSNotificationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSNotificationResponse: TTCN_Logger::log_event_str("{ mBMSNotificationResponse := "); field_mBMSNotificationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSNotificationRejectRequest: TTCN_Logger::log_event_str("{ mBMSNotificationRejectRequest := "); field_mBMSNotificationRejectRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSNotificationRejectResponse: TTCN_Logger::log_event_str("{ mBMSNotificationRejectResponse := "); field_mBMSNotificationRejectResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_createMBMSContextRequest: TTCN_Logger::log_event_str("{ createMBMSContextRequest := "); field_createMBMSContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_createMBMSContextResponse: TTCN_Logger::log_event_str("{ createMBMSContextResponse := "); field_createMBMSContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_updateMBMSContextRequest: TTCN_Logger::log_event_str("{ updateMBMSContextRequest := "); field_updateMBMSContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_updateMBMSContextResponse: TTCN_Logger::log_event_str("{ updateMBMSContextResponse := "); field_updateMBMSContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_deleteMBMSContextRequest: TTCN_Logger::log_event_str("{ deleteMBMSContextRequest := "); field_deleteMBMSContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_deleteMBMSContextResponse: TTCN_Logger::log_event_str("{ deleteMBMSContextResponse := "); field_deleteMBMSContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSRegistrationRequest: TTCN_Logger::log_event_str("{ mBMSRegistrationRequest := "); field_mBMSRegistrationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSRegistrationResponse: TTCN_Logger::log_event_str("{ mBMSRegistrationResponse := "); field_mBMSRegistrationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSDeRegistrationRequest: TTCN_Logger::log_event_str("{ mBMSDeRegistrationRequest := "); field_mBMSDeRegistrationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSDeRegistrationResponse: TTCN_Logger::log_event_str("{ mBMSDeRegistrationResponse := "); field_mBMSDeRegistrationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSSessionStartRequest: TTCN_Logger::log_event_str("{ mBMSSessionStartRequest := "); field_mBMSSessionStartRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSSessionStartResponse: TTCN_Logger::log_event_str("{ mBMSSessionStartResponse := "); field_mBMSSessionStartResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSSessionStopRequest: TTCN_Logger::log_event_str("{ mBMSSessionStopRequest := "); field_mBMSSessionStopRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSSessionStopResponse: TTCN_Logger::log_event_str("{ mBMSSessionStopResponse := "); field_mBMSSessionStopResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSSessionUpdateRequest: TTCN_Logger::log_event_str("{ mBMSSessionUpdateRequest := "); field_mBMSSessionUpdateRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mBMSSessionUpdateResponse: TTCN_Logger::log_event_str("{ mBMSSessionUpdateResponse := "); field_mBMSSessionUpdateResponse->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mS__InfoChangeNotificationRequest: TTCN_Logger::log_event_str("{ mS_InfoChangeNotificationRequest := "); field_mS__InfoChangeNotificationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case ALT_mS__InfoChangeNotificationResponse: TTCN_Logger::log_event_str("{ mS_InfoChangeNotificationResponse := "); field_mS__InfoChangeNotificationResponse->log(); TTCN_Logger::log_event_str(" }"); break; default: TTCN_Logger::log_event_unbound(); } } void GTPC__PDUs::set_param(Module_Param& param) { param.basic_check(Module_Param::BC_VALUE, "union value"); Module_Param_Ptr m_p = ¶m; if (m_p->get_type()==Module_Param::MP_Value_List && m_p->get_size()==0) return; if (m_p->get_type()!=Module_Param::MP_Assignment_List) { param.error("union value with field name was expected"); } Module_Param* mp_last = m_p->get_elem(m_p->get_size()-1); char* last_name = mp_last->get_id()->get_name(); if (!strcmp(last_name, "echoRequest")) { echoRequest().set_param(*mp_last); if (!echoRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "echoResponse")) { echoResponse().set_param(*mp_last); if (!echoResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "versionNotSupported")) { versionNotSupported().set_param(*mp_last); if (!versionNotSupported().is_bound()) clean_up(); return; } if (!strcmp(last_name, "createPDPContextRequest")) { createPDPContextRequest().set_param(*mp_last); if (!createPDPContextRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "createPDPContextResponse")) { createPDPContextResponse().set_param(*mp_last); if (!createPDPContextResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "updatePDPContextRequest")) { updatePDPContextRequest().set_param(*mp_last); if (!updatePDPContextRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "updatePDPContextResponse")) { updatePDPContextResponse().set_param(*mp_last); if (!updatePDPContextResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "deletePDPContextRequest")) { deletePDPContextRequest().set_param(*mp_last); if (!deletePDPContextRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "deletePDPContextResponse")) { deletePDPContextResponse().set_param(*mp_last); if (!deletePDPContextResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "pdu_NotificationRequest")) { pdu__NotificationRequest().set_param(*mp_last); if (!pdu__NotificationRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "pdu_NotificationResponse")) { pdu__NotificationResponse().set_param(*mp_last); if (!pdu__NotificationResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "pdu_NotificationRejectRequest")) { pdu__NotificationRejectRequest().set_param(*mp_last); if (!pdu__NotificationRejectRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "pdu_NotificationRejectResponse")) { pdu__NotificationRejectResponse().set_param(*mp_last); if (!pdu__NotificationRejectResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "initiatePDPContextActivationRequest")) { initiatePDPContextActivationRequest().set_param(*mp_last); if (!initiatePDPContextActivationRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "initiatePDPContextActivationResponse")) { initiatePDPContextActivationResponse().set_param(*mp_last); if (!initiatePDPContextActivationResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "supportedExtensionHeadersNotification")) { supportedExtensionHeadersNotification().set_param(*mp_last); if (!supportedExtensionHeadersNotification().is_bound()) clean_up(); return; } if (!strcmp(last_name, "sendRouteingInformationForGPRSRequest")) { sendRouteingInformationForGPRSRequest().set_param(*mp_last); if (!sendRouteingInformationForGPRSRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "sendRouteingInformationForGPRSResponse")) { sendRouteingInformationForGPRSResponse().set_param(*mp_last); if (!sendRouteingInformationForGPRSResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "failureReportRequest")) { failureReportRequest().set_param(*mp_last); if (!failureReportRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "failureReportResponse")) { failureReportResponse().set_param(*mp_last); if (!failureReportResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "noteMS_GPRSPresentRequest")) { noteMS__GPRSPresentRequest().set_param(*mp_last); if (!noteMS__GPRSPresentRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "noteMS_GPRSPresentResponse")) { noteMS__GPRSPresentResponse().set_param(*mp_last); if (!noteMS__GPRSPresentResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "identificationRequest")) { identificationRequest().set_param(*mp_last); if (!identificationRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "identificationResponse")) { identificationResponse().set_param(*mp_last); if (!identificationResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "sgsn_ContextRequest")) { sgsn__ContextRequest().set_param(*mp_last); if (!sgsn__ContextRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "sgsn_ContextResponse")) { sgsn__ContextResponse().set_param(*mp_last); if (!sgsn__ContextResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "sgsn_ContextAcknowledge")) { sgsn__ContextAcknowledge().set_param(*mp_last); if (!sgsn__ContextAcknowledge().is_bound()) clean_up(); return; } if (!strcmp(last_name, "forwardRelocationRequest")) { forwardRelocationRequest().set_param(*mp_last); if (!forwardRelocationRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "forwardRelocationResponse")) { forwardRelocationResponse().set_param(*mp_last); if (!forwardRelocationResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "forwardRelocationComplete")) { forwardRelocationComplete().set_param(*mp_last); if (!forwardRelocationComplete().is_bound()) clean_up(); return; } if (!strcmp(last_name, "relocationCancelRequest")) { relocationCancelRequest().set_param(*mp_last); if (!relocationCancelRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "relocationCancelResponse")) { relocationCancelResponse().set_param(*mp_last); if (!relocationCancelResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "forwardSRNSContext")) { forwardSRNSContext().set_param(*mp_last); if (!forwardSRNSContext().is_bound()) clean_up(); return; } if (!strcmp(last_name, "forwardRelocationCompleteAcknowledge")) { forwardRelocationCompleteAcknowledge().set_param(*mp_last); if (!forwardRelocationCompleteAcknowledge().is_bound()) clean_up(); return; } if (!strcmp(last_name, "forwardSRNSContextAcknowledge")) { forwardSRNSContextAcknowledge().set_param(*mp_last); if (!forwardSRNSContextAcknowledge().is_bound()) clean_up(); return; } if (!strcmp(last_name, "uERegistrationQueryRequest")) { uERegistrationQueryRequest().set_param(*mp_last); if (!uERegistrationQueryRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "uERegistrationQueryResponse")) { uERegistrationQueryResponse().set_param(*mp_last); if (!uERegistrationQueryResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "ranInformationRelay")) { ranInformationRelay().set_param(*mp_last); if (!ranInformationRelay().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSNotificationRequest")) { mBMSNotificationRequest().set_param(*mp_last); if (!mBMSNotificationRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSNotificationResponse")) { mBMSNotificationResponse().set_param(*mp_last); if (!mBMSNotificationResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSNotificationRejectRequest")) { mBMSNotificationRejectRequest().set_param(*mp_last); if (!mBMSNotificationRejectRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSNotificationRejectResponse")) { mBMSNotificationRejectResponse().set_param(*mp_last); if (!mBMSNotificationRejectResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "createMBMSContextRequest")) { createMBMSContextRequest().set_param(*mp_last); if (!createMBMSContextRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "createMBMSContextResponse")) { createMBMSContextResponse().set_param(*mp_last); if (!createMBMSContextResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "updateMBMSContextRequest")) { updateMBMSContextRequest().set_param(*mp_last); if (!updateMBMSContextRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "updateMBMSContextResponse")) { updateMBMSContextResponse().set_param(*mp_last); if (!updateMBMSContextResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "deleteMBMSContextRequest")) { deleteMBMSContextRequest().set_param(*mp_last); if (!deleteMBMSContextRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "deleteMBMSContextResponse")) { deleteMBMSContextResponse().set_param(*mp_last); if (!deleteMBMSContextResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSRegistrationRequest")) { mBMSRegistrationRequest().set_param(*mp_last); if (!mBMSRegistrationRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSRegistrationResponse")) { mBMSRegistrationResponse().set_param(*mp_last); if (!mBMSRegistrationResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSDeRegistrationRequest")) { mBMSDeRegistrationRequest().set_param(*mp_last); if (!mBMSDeRegistrationRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSDeRegistrationResponse")) { mBMSDeRegistrationResponse().set_param(*mp_last); if (!mBMSDeRegistrationResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSSessionStartRequest")) { mBMSSessionStartRequest().set_param(*mp_last); if (!mBMSSessionStartRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSSessionStartResponse")) { mBMSSessionStartResponse().set_param(*mp_last); if (!mBMSSessionStartResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSSessionStopRequest")) { mBMSSessionStopRequest().set_param(*mp_last); if (!mBMSSessionStopRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSSessionStopResponse")) { mBMSSessionStopResponse().set_param(*mp_last); if (!mBMSSessionStopResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSSessionUpdateRequest")) { mBMSSessionUpdateRequest().set_param(*mp_last); if (!mBMSSessionUpdateRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mBMSSessionUpdateResponse")) { mBMSSessionUpdateResponse().set_param(*mp_last); if (!mBMSSessionUpdateResponse().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mS_InfoChangeNotificationRequest")) { mS__InfoChangeNotificationRequest().set_param(*mp_last); if (!mS__InfoChangeNotificationRequest().is_bound()) clean_up(); return; } if (!strcmp(last_name, "mS_InfoChangeNotificationResponse")) { mS__InfoChangeNotificationResponse().set_param(*mp_last); if (!mS__InfoChangeNotificationResponse().is_bound()) clean_up(); return; } mp_last->error("Field %s does not exist in type @GTPC_Types.GTPC_PDUs.", last_name); } void GTPC__PDUs::set_implicit_omit() { switch (union_selection) { case ALT_echoRequest: field_echoRequest->set_implicit_omit(); break; case ALT_echoResponse: field_echoResponse->set_implicit_omit(); break; case ALT_versionNotSupported: field_versionNotSupported->set_implicit_omit(); break; case ALT_createPDPContextRequest: field_createPDPContextRequest->set_implicit_omit(); break; case ALT_createPDPContextResponse: field_createPDPContextResponse->set_implicit_omit(); break; case ALT_updatePDPContextRequest: field_updatePDPContextRequest->set_implicit_omit(); break; case ALT_updatePDPContextResponse: field_updatePDPContextResponse->set_implicit_omit(); break; case ALT_deletePDPContextRequest: field_deletePDPContextRequest->set_implicit_omit(); break; case ALT_deletePDPContextResponse: field_deletePDPContextResponse->set_implicit_omit(); break; case ALT_pdu__NotificationRequest: field_pdu__NotificationRequest->set_implicit_omit(); break; case ALT_pdu__NotificationResponse: field_pdu__NotificationResponse->set_implicit_omit(); break; case ALT_pdu__NotificationRejectRequest: field_pdu__NotificationRejectRequest->set_implicit_omit(); break; case ALT_pdu__NotificationRejectResponse: field_pdu__NotificationRejectResponse->set_implicit_omit(); break; case ALT_initiatePDPContextActivationRequest: field_initiatePDPContextActivationRequest->set_implicit_omit(); break; case ALT_initiatePDPContextActivationResponse: field_initiatePDPContextActivationResponse->set_implicit_omit(); break; case ALT_supportedExtensionHeadersNotification: field_supportedExtensionHeadersNotification->set_implicit_omit(); break; case ALT_sendRouteingInformationForGPRSRequest: field_sendRouteingInformationForGPRSRequest->set_implicit_omit(); break; case ALT_sendRouteingInformationForGPRSResponse: field_sendRouteingInformationForGPRSResponse->set_implicit_omit(); break; case ALT_failureReportRequest: field_failureReportRequest->set_implicit_omit(); break; case ALT_failureReportResponse: field_failureReportResponse->set_implicit_omit(); break; case ALT_noteMS__GPRSPresentRequest: field_noteMS__GPRSPresentRequest->set_implicit_omit(); break; case ALT_noteMS__GPRSPresentResponse: field_noteMS__GPRSPresentResponse->set_implicit_omit(); break; case ALT_identificationRequest: field_identificationRequest->set_implicit_omit(); break; case ALT_identificationResponse: field_identificationResponse->set_implicit_omit(); break; case ALT_sgsn__ContextRequest: field_sgsn__ContextRequest->set_implicit_omit(); break; case ALT_sgsn__ContextResponse: field_sgsn__ContextResponse->set_implicit_omit(); break; case ALT_sgsn__ContextAcknowledge: field_sgsn__ContextAcknowledge->set_implicit_omit(); break; case ALT_forwardRelocationRequest: field_forwardRelocationRequest->set_implicit_omit(); break; case ALT_forwardRelocationResponse: field_forwardRelocationResponse->set_implicit_omit(); break; case ALT_forwardRelocationComplete: field_forwardRelocationComplete->set_implicit_omit(); break; case ALT_relocationCancelRequest: field_relocationCancelRequest->set_implicit_omit(); break; case ALT_relocationCancelResponse: field_relocationCancelResponse->set_implicit_omit(); break; case ALT_forwardSRNSContext: field_forwardSRNSContext->set_implicit_omit(); break; case ALT_forwardRelocationCompleteAcknowledge: field_forwardRelocationCompleteAcknowledge->set_implicit_omit(); break; case ALT_forwardSRNSContextAcknowledge: field_forwardSRNSContextAcknowledge->set_implicit_omit(); break; case ALT_uERegistrationQueryRequest: field_uERegistrationQueryRequest->set_implicit_omit(); break; case ALT_uERegistrationQueryResponse: field_uERegistrationQueryResponse->set_implicit_omit(); break; case ALT_ranInformationRelay: field_ranInformationRelay->set_implicit_omit(); break; case ALT_mBMSNotificationRequest: field_mBMSNotificationRequest->set_implicit_omit(); break; case ALT_mBMSNotificationResponse: field_mBMSNotificationResponse->set_implicit_omit(); break; case ALT_mBMSNotificationRejectRequest: field_mBMSNotificationRejectRequest->set_implicit_omit(); break; case ALT_mBMSNotificationRejectResponse: field_mBMSNotificationRejectResponse->set_implicit_omit(); break; case ALT_createMBMSContextRequest: field_createMBMSContextRequest->set_implicit_omit(); break; case ALT_createMBMSContextResponse: field_createMBMSContextResponse->set_implicit_omit(); break; case ALT_updateMBMSContextRequest: field_updateMBMSContextRequest->set_implicit_omit(); break; case ALT_updateMBMSContextResponse: field_updateMBMSContextResponse->set_implicit_omit(); break; case ALT_deleteMBMSContextRequest: field_deleteMBMSContextRequest->set_implicit_omit(); break; case ALT_deleteMBMSContextResponse: field_deleteMBMSContextResponse->set_implicit_omit(); break; case ALT_mBMSRegistrationRequest: field_mBMSRegistrationRequest->set_implicit_omit(); break; case ALT_mBMSRegistrationResponse: field_mBMSRegistrationResponse->set_implicit_omit(); break; case ALT_mBMSDeRegistrationRequest: field_mBMSDeRegistrationRequest->set_implicit_omit(); break; case ALT_mBMSDeRegistrationResponse: field_mBMSDeRegistrationResponse->set_implicit_omit(); break; case ALT_mBMSSessionStartRequest: field_mBMSSessionStartRequest->set_implicit_omit(); break; case ALT_mBMSSessionStartResponse: field_mBMSSessionStartResponse->set_implicit_omit(); break; case ALT_mBMSSessionStopRequest: field_mBMSSessionStopRequest->set_implicit_omit(); break; case ALT_mBMSSessionStopResponse: field_mBMSSessionStopResponse->set_implicit_omit(); break; case ALT_mBMSSessionUpdateRequest: field_mBMSSessionUpdateRequest->set_implicit_omit(); break; case ALT_mBMSSessionUpdateResponse: field_mBMSSessionUpdateResponse->set_implicit_omit(); break; case ALT_mS__InfoChangeNotificationRequest: field_mS__InfoChangeNotificationRequest->set_implicit_omit(); break; case ALT_mS__InfoChangeNotificationResponse: field_mS__InfoChangeNotificationResponse->set_implicit_omit(); break; default: break; } } void GTPC__PDUs::encode_text(Text_Buf& text_buf) const { text_buf.push_int(union_selection); switch (union_selection) { case ALT_echoRequest: field_echoRequest->encode_text(text_buf); break; case ALT_echoResponse: field_echoResponse->encode_text(text_buf); break; case ALT_versionNotSupported: field_versionNotSupported->encode_text(text_buf); break; case ALT_createPDPContextRequest: field_createPDPContextRequest->encode_text(text_buf); break; case ALT_createPDPContextResponse: field_createPDPContextResponse->encode_text(text_buf); break; case ALT_updatePDPContextRequest: field_updatePDPContextRequest->encode_text(text_buf); break; case ALT_updatePDPContextResponse: field_updatePDPContextResponse->encode_text(text_buf); break; case ALT_deletePDPContextRequest: field_deletePDPContextRequest->encode_text(text_buf); break; case ALT_deletePDPContextResponse: field_deletePDPContextResponse->encode_text(text_buf); break; case ALT_pdu__NotificationRequest: field_pdu__NotificationRequest->encode_text(text_buf); break; case ALT_pdu__NotificationResponse: field_pdu__NotificationResponse->encode_text(text_buf); break; case ALT_pdu__NotificationRejectRequest: field_pdu__NotificationRejectRequest->encode_text(text_buf); break; case ALT_pdu__NotificationRejectResponse: field_pdu__NotificationRejectResponse->encode_text(text_buf); break; case ALT_initiatePDPContextActivationRequest: field_initiatePDPContextActivationRequest->encode_text(text_buf); break; case ALT_initiatePDPContextActivationResponse: field_initiatePDPContextActivationResponse->encode_text(text_buf); break; case ALT_supportedExtensionHeadersNotification: field_supportedExtensionHeadersNotification->encode_text(text_buf); break; case ALT_sendRouteingInformationForGPRSRequest: field_sendRouteingInformationForGPRSRequest->encode_text(text_buf); break; case ALT_sendRouteingInformationForGPRSResponse: field_sendRouteingInformationForGPRSResponse->encode_text(text_buf); break; case ALT_failureReportRequest: field_failureReportRequest->encode_text(text_buf); break; case ALT_failureReportResponse: field_failureReportResponse->encode_text(text_buf); break; case ALT_noteMS__GPRSPresentRequest: field_noteMS__GPRSPresentRequest->encode_text(text_buf); break; case ALT_noteMS__GPRSPresentResponse: field_noteMS__GPRSPresentResponse->encode_text(text_buf); break; case ALT_identificationRequest: field_identificationRequest->encode_text(text_buf); break; case ALT_identificationResponse: field_identificationResponse->encode_text(text_buf); break; case ALT_sgsn__ContextRequest: field_sgsn__ContextRequest->encode_text(text_buf); break; case ALT_sgsn__ContextResponse: field_sgsn__ContextResponse->encode_text(text_buf); break; case ALT_sgsn__ContextAcknowledge: field_sgsn__ContextAcknowledge->encode_text(text_buf); break; case ALT_forwardRelocationRequest: field_forwardRelocationRequest->encode_text(text_buf); break; case ALT_forwardRelocationResponse: field_forwardRelocationResponse->encode_text(text_buf); break; case ALT_forwardRelocationComplete: field_forwardRelocationComplete->encode_text(text_buf); break; case ALT_relocationCancelRequest: field_relocationCancelRequest->encode_text(text_buf); break; case ALT_relocationCancelResponse: field_relocationCancelResponse->encode_text(text_buf); break; case ALT_forwardSRNSContext: field_forwardSRNSContext->encode_text(text_buf); break; case ALT_forwardRelocationCompleteAcknowledge: field_forwardRelocationCompleteAcknowledge->encode_text(text_buf); break; case ALT_forwardSRNSContextAcknowledge: field_forwardSRNSContextAcknowledge->encode_text(text_buf); break; case ALT_uERegistrationQueryRequest: field_uERegistrationQueryRequest->encode_text(text_buf); break; case ALT_uERegistrationQueryResponse: field_uERegistrationQueryResponse->encode_text(text_buf); break; case ALT_ranInformationRelay: field_ranInformationRelay->encode_text(text_buf); break; case ALT_mBMSNotificationRequest: field_mBMSNotificationRequest->encode_text(text_buf); break; case ALT_mBMSNotificationResponse: field_mBMSNotificationResponse->encode_text(text_buf); break; case ALT_mBMSNotificationRejectRequest: field_mBMSNotificationRejectRequest->encode_text(text_buf); break; case ALT_mBMSNotificationRejectResponse: field_mBMSNotificationRejectResponse->encode_text(text_buf); break; case ALT_createMBMSContextRequest: field_createMBMSContextRequest->encode_text(text_buf); break; case ALT_createMBMSContextResponse: field_createMBMSContextResponse->encode_text(text_buf); break; case ALT_updateMBMSContextRequest: field_updateMBMSContextRequest->encode_text(text_buf); break; case ALT_updateMBMSContextResponse: field_updateMBMSContextResponse->encode_text(text_buf); break; case ALT_deleteMBMSContextRequest: field_deleteMBMSContextRequest->encode_text(text_buf); break; case ALT_deleteMBMSContextResponse: field_deleteMBMSContextResponse->encode_text(text_buf); break; case ALT_mBMSRegistrationRequest: field_mBMSRegistrationRequest->encode_text(text_buf); break; case ALT_mBMSRegistrationResponse: field_mBMSRegistrationResponse->encode_text(text_buf); break; case ALT_mBMSDeRegistrationRequest: field_mBMSDeRegistrationRequest->encode_text(text_buf); break; case ALT_mBMSDeRegistrationResponse: field_mBMSDeRegistrationResponse->encode_text(text_buf); break; case ALT_mBMSSessionStartRequest: field_mBMSSessionStartRequest->encode_text(text_buf); break; case ALT_mBMSSessionStartResponse: field_mBMSSessionStartResponse->encode_text(text_buf); break; case ALT_mBMSSessionStopRequest: field_mBMSSessionStopRequest->encode_text(text_buf); break; case ALT_mBMSSessionStopResponse: field_mBMSSessionStopResponse->encode_text(text_buf); break; case ALT_mBMSSessionUpdateRequest: field_mBMSSessionUpdateRequest->encode_text(text_buf); break; case ALT_mBMSSessionUpdateResponse: field_mBMSSessionUpdateResponse->encode_text(text_buf); break; case ALT_mS__InfoChangeNotificationRequest: field_mS__InfoChangeNotificationRequest->encode_text(text_buf); break; case ALT_mS__InfoChangeNotificationResponse: field_mS__InfoChangeNotificationResponse->encode_text(text_buf); break; default: TTCN_error("Text encoder: Encoding an unbound value of union type @GTPC_Types.GTPC_PDUs."); } } void GTPC__PDUs::decode_text(Text_Buf& text_buf) { switch ((union_selection_type)text_buf.pull_int().get_val()) { case ALT_echoRequest: echoRequest().decode_text(text_buf); break; case ALT_echoResponse: echoResponse().decode_text(text_buf); break; case ALT_versionNotSupported: versionNotSupported().decode_text(text_buf); break; case ALT_createPDPContextRequest: createPDPContextRequest().decode_text(text_buf); break; case ALT_createPDPContextResponse: createPDPContextResponse().decode_text(text_buf); break; case ALT_updatePDPContextRequest: updatePDPContextRequest().decode_text(text_buf); break; case ALT_updatePDPContextResponse: updatePDPContextResponse().decode_text(text_buf); break; case ALT_deletePDPContextRequest: deletePDPContextRequest().decode_text(text_buf); break; case ALT_deletePDPContextResponse: deletePDPContextResponse().decode_text(text_buf); break; case ALT_pdu__NotificationRequest: pdu__NotificationRequest().decode_text(text_buf); break; case ALT_pdu__NotificationResponse: pdu__NotificationResponse().decode_text(text_buf); break; case ALT_pdu__NotificationRejectRequest: pdu__NotificationRejectRequest().decode_text(text_buf); break; case ALT_pdu__NotificationRejectResponse: pdu__NotificationRejectResponse().decode_text(text_buf); break; case ALT_initiatePDPContextActivationRequest: initiatePDPContextActivationRequest().decode_text(text_buf); break; case ALT_initiatePDPContextActivationResponse: initiatePDPContextActivationResponse().decode_text(text_buf); break; case ALT_supportedExtensionHeadersNotification: supportedExtensionHeadersNotification().decode_text(text_buf); break; case ALT_sendRouteingInformationForGPRSRequest: sendRouteingInformationForGPRSRequest().decode_text(text_buf); break; case ALT_sendRouteingInformationForGPRSResponse: sendRouteingInformationForGPRSResponse().decode_text(text_buf); break; case ALT_failureReportRequest: failureReportRequest().decode_text(text_buf); break; case ALT_failureReportResponse: failureReportResponse().decode_text(text_buf); break; case ALT_noteMS__GPRSPresentRequest: noteMS__GPRSPresentRequest().decode_text(text_buf); break; case ALT_noteMS__GPRSPresentResponse: noteMS__GPRSPresentResponse().decode_text(text_buf); break; case ALT_identificationRequest: identificationRequest().decode_text(text_buf); break; case ALT_identificationResponse: identificationResponse().decode_text(text_buf); break; case ALT_sgsn__ContextRequest: sgsn__ContextRequest().decode_text(text_buf); break; case ALT_sgsn__ContextResponse: sgsn__ContextResponse().decode_text(text_buf); break; case ALT_sgsn__ContextAcknowledge: sgsn__ContextAcknowledge().decode_text(text_buf); break; case ALT_forwardRelocationRequest: forwardRelocationRequest().decode_text(text_buf); break; case ALT_forwardRelocationResponse: forwardRelocationResponse().decode_text(text_buf); break; case ALT_forwardRelocationComplete: forwardRelocationComplete().decode_text(text_buf); break; case ALT_relocationCancelRequest: relocationCancelRequest().decode_text(text_buf); break; case ALT_relocationCancelResponse: relocationCancelResponse().decode_text(text_buf); break; case ALT_forwardSRNSContext: forwardSRNSContext().decode_text(text_buf); break; case ALT_forwardRelocationCompleteAcknowledge: forwardRelocationCompleteAcknowledge().decode_text(text_buf); break; case ALT_forwardSRNSContextAcknowledge: forwardSRNSContextAcknowledge().decode_text(text_buf); break; case ALT_uERegistrationQueryRequest: uERegistrationQueryRequest().decode_text(text_buf); break; case ALT_uERegistrationQueryResponse: uERegistrationQueryResponse().decode_text(text_buf); break; case ALT_ranInformationRelay: ranInformationRelay().decode_text(text_buf); break; case ALT_mBMSNotificationRequest: mBMSNotificationRequest().decode_text(text_buf); break; case ALT_mBMSNotificationResponse: mBMSNotificationResponse().decode_text(text_buf); break; case ALT_mBMSNotificationRejectRequest: mBMSNotificationRejectRequest().decode_text(text_buf); break; case ALT_mBMSNotificationRejectResponse: mBMSNotificationRejectResponse().decode_text(text_buf); break; case ALT_createMBMSContextRequest: createMBMSContextRequest().decode_text(text_buf); break; case ALT_createMBMSContextResponse: createMBMSContextResponse().decode_text(text_buf); break; case ALT_updateMBMSContextRequest: updateMBMSContextRequest().decode_text(text_buf); break; case ALT_updateMBMSContextResponse: updateMBMSContextResponse().decode_text(text_buf); break; case ALT_deleteMBMSContextRequest: deleteMBMSContextRequest().decode_text(text_buf); break; case ALT_deleteMBMSContextResponse: deleteMBMSContextResponse().decode_text(text_buf); break; case ALT_mBMSRegistrationRequest: mBMSRegistrationRequest().decode_text(text_buf); break; case ALT_mBMSRegistrationResponse: mBMSRegistrationResponse().decode_text(text_buf); break; case ALT_mBMSDeRegistrationRequest: mBMSDeRegistrationRequest().decode_text(text_buf); break; case ALT_mBMSDeRegistrationResponse: mBMSDeRegistrationResponse().decode_text(text_buf); break; case ALT_mBMSSessionStartRequest: mBMSSessionStartRequest().decode_text(text_buf); break; case ALT_mBMSSessionStartResponse: mBMSSessionStartResponse().decode_text(text_buf); break; case ALT_mBMSSessionStopRequest: mBMSSessionStopRequest().decode_text(text_buf); break; case ALT_mBMSSessionStopResponse: mBMSSessionStopResponse().decode_text(text_buf); break; case ALT_mBMSSessionUpdateRequest: mBMSSessionUpdateRequest().decode_text(text_buf); break; case ALT_mBMSSessionUpdateResponse: mBMSSessionUpdateResponse().decode_text(text_buf); break; case ALT_mS__InfoChangeNotificationRequest: mS__InfoChangeNotificationRequest().decode_text(text_buf); break; case ALT_mS__InfoChangeNotificationResponse: mS__InfoChangeNotificationResponse().decode_text(text_buf); break; default: TTCN_error("Text decoder: Unrecognized union selector was received for type @GTPC_Types.GTPC_PDUs."); } } void GTPC__PDUs::encode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) const { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-encoding type '%s': ", p_td.name); unsigned BER_coding=va_arg(pvar, unsigned); BER_encode_chk_coding(BER_coding); ASN_BER_TLV_t *tlv=BER_encode_TLV(p_td, BER_coding); tlv->put_in_buffer(p_buf); ASN_BER_TLV_t::destruct(tlv); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-encoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); RAW_enc_tr_pos rp; rp.level=0; rp.pos=NULL; RAW_enc_tree root(TRUE, NULL, &rp, 1, p_td.raw); RAW_encode(p_td, root); root.put_to_buf(p_buf); break;} case TTCN_EncDec::CT_TEXT: { TTCN_EncDec_ErrorContext ec("While TEXT-encoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); TEXT_encode(p_td,p_buf); break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-encoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XER_encode(*(p_td.xer),p_buf, XER_coding, 0, 0, 0); p_buf.put_c('\n'); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-encoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok(va_arg(pvar, int) != 0); JSON_encode(p_td, tok, FALSE); p_buf.put_s(tok.get_buffer_length(), (const unsigned char*)tok.get_buffer()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-encoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_encode(p_td, p_buf); break;} default: TTCN_error("Unknown coding method requested to encode type '%s'", p_td.name); } va_end(pvar); } void GTPC__PDUs::decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-decoding type '%s': ", p_td.name); unsigned L_form=va_arg(pvar, unsigned); ASN_BER_TLV_t tlv; BER_decode_str2TLV(p_buf, tlv, L_form); BER_decode_TLV(p_td, tlv, L_form); if(tlv.isComplete) p_buf.increase_pos(tlv.get_len()); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-decoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); raw_order_t r_order; switch(p_td.raw->top_bit_order) { case TOP_BIT_LEFT: r_order=ORDER_LSB; break; case TOP_BIT_RIGHT: default: r_order=ORDER_MSB; } int rawr = RAW_decode(p_td, p_buf, p_buf.get_len()*8, r_order); if(rawr<0) switch (-rawr) { case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: ec.error((TTCN_EncDec::error_type_t)-rawr, "Can not decode type '%s', because incomplete message was received", p_td.name); break; case 1: default: ec.error(TTCN_EncDec::ET_INVAL_MSG, "Can not decode type '%s', because invalid message was received", p_td.name); break; } break;} case TTCN_EncDec::CT_TEXT: { Limit_Token_List limit; TTCN_EncDec_ErrorContext ec("While TEXT-decoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); const unsigned char *b_data=p_buf.get_data(); int null_added=0; if(b_data[p_buf.get_len()-1]!='\0'){ null_added=1; p_buf.set_pos(p_buf.get_len()); p_buf.put_zero(8,ORDER_LSB); p_buf.rewind(); } if(TEXT_decode(p_td,p_buf,limit)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); if(null_added){ size_t actpos=p_buf.get_pos(); p_buf.set_pos(p_buf.get_len()-1); p_buf.cut_end(); p_buf.set_pos(actpos); } break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-decoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XmlReaderWrap reader(p_buf); for (int rd_ok=reader.Read(); rd_ok==1; rd_ok=reader.Read()) { if (reader.NodeType() == XML_READER_TYPE_ELEMENT) break; } XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL, XER_NONE, 0); size_t bytes = reader.ByteConsumed(); p_buf.set_pos(bytes); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-decoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok((const char*)p_buf.get_data(), p_buf.get_len()); if(JSON_decode(p_td, tok, FALSE, FALSE)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); p_buf.set_pos(tok.get_buf_pos()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-decoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_struct p_oer; OER_decode(p_td, p_buf, p_oer); break;} default: TTCN_error("Unknown coding method requested to decode type '%s'", p_td.name); } va_end(pvar); } int GTPC__PDUs::RAW_decode( const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int limit, raw_order_t top_bit_ord, boolean no_err, int sel_field, boolean, const RAW_Force_Omit* force_omit) { int prepaddlength=p_buf.increase_pos_padd(p_td.raw->prepadding); limit-=prepaddlength; int decoded_length=0; int starting_pos=p_buf.get_pos_bit(); if(sel_field!=-1){ switch(sel_field){ case 0: { RAW_Force_Omit field_force_omit(0, force_omit, EchoRequest_descr_.raw->forceomit); decoded_length = echoRequest().RAW_decode(EchoRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 1: { RAW_Force_Omit field_force_omit(1, force_omit, EchoResponse_descr_.raw->forceomit); decoded_length = echoResponse().RAW_decode(EchoResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 2: { RAW_Force_Omit field_force_omit(2, force_omit, VersionNotSupported_descr_.raw->forceomit); decoded_length = versionNotSupported().RAW_decode(VersionNotSupported_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 3: { RAW_Force_Omit field_force_omit(3, force_omit, CreatePDPContextRequest_descr_.raw->forceomit); decoded_length = createPDPContextRequest().RAW_decode(CreatePDPContextRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 4: { RAW_Force_Omit field_force_omit(4, force_omit, CreatePDPContextResponse_descr_.raw->forceomit); decoded_length = createPDPContextResponse().RAW_decode(CreatePDPContextResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 5: { RAW_Force_Omit field_force_omit(5, force_omit, UpdatePDPContextRequest_descr_.raw->forceomit); decoded_length = updatePDPContextRequest().RAW_decode(UpdatePDPContextRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 6: { RAW_Force_Omit field_force_omit(6, force_omit, UpdatePDPContextResponse_descr_.raw->forceomit); decoded_length = updatePDPContextResponse().RAW_decode(UpdatePDPContextResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 7: { RAW_Force_Omit field_force_omit(7, force_omit, DeletePDPContextRequest_descr_.raw->forceomit); decoded_length = deletePDPContextRequest().RAW_decode(DeletePDPContextRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 8: { RAW_Force_Omit field_force_omit(8, force_omit, DeletePDPContextResponse_descr_.raw->forceomit); decoded_length = deletePDPContextResponse().RAW_decode(DeletePDPContextResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 9: { RAW_Force_Omit field_force_omit(9, force_omit, PDU__NotificationRequest_descr_.raw->forceomit); decoded_length = pdu__NotificationRequest().RAW_decode(PDU__NotificationRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 10: { RAW_Force_Omit field_force_omit(10, force_omit, PDU__NotificationResponse_descr_.raw->forceomit); decoded_length = pdu__NotificationResponse().RAW_decode(PDU__NotificationResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 11: { RAW_Force_Omit field_force_omit(11, force_omit, PDU__NotificationRejectRequest_descr_.raw->forceomit); decoded_length = pdu__NotificationRejectRequest().RAW_decode(PDU__NotificationRejectRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 12: { RAW_Force_Omit field_force_omit(12, force_omit, PDU__NotificationRejectResponse_descr_.raw->forceomit); decoded_length = pdu__NotificationRejectResponse().RAW_decode(PDU__NotificationRejectResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 13: { RAW_Force_Omit field_force_omit(13, force_omit, InitiatePDPContextActivationRequest_descr_.raw->forceomit); decoded_length = initiatePDPContextActivationRequest().RAW_decode(InitiatePDPContextActivationRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 14: { RAW_Force_Omit field_force_omit(14, force_omit, InitiatePDPContextActivationResponse_descr_.raw->forceomit); decoded_length = initiatePDPContextActivationResponse().RAW_decode(InitiatePDPContextActivationResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 15: { RAW_Force_Omit field_force_omit(15, force_omit, SupportedExtensionHeadersNotification_descr_.raw->forceomit); decoded_length = supportedExtensionHeadersNotification().RAW_decode(SupportedExtensionHeadersNotification_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 16: { RAW_Force_Omit field_force_omit(16, force_omit, SendRouteingInformationForGPRSRequest_descr_.raw->forceomit); decoded_length = sendRouteingInformationForGPRSRequest().RAW_decode(SendRouteingInformationForGPRSRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 17: { RAW_Force_Omit field_force_omit(17, force_omit, SendRouteingInformationForGPRSResponse_descr_.raw->forceomit); decoded_length = sendRouteingInformationForGPRSResponse().RAW_decode(SendRouteingInformationForGPRSResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 18: { RAW_Force_Omit field_force_omit(18, force_omit, FailureReportRequest_descr_.raw->forceomit); decoded_length = failureReportRequest().RAW_decode(FailureReportRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 19: { RAW_Force_Omit field_force_omit(19, force_omit, FailureReportResponse_descr_.raw->forceomit); decoded_length = failureReportResponse().RAW_decode(FailureReportResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 20: { RAW_Force_Omit field_force_omit(20, force_omit, NoteMS__GPRSPresentRequest_descr_.raw->forceomit); decoded_length = noteMS__GPRSPresentRequest().RAW_decode(NoteMS__GPRSPresentRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 21: { RAW_Force_Omit field_force_omit(21, force_omit, NoteMS__GPRSPresentResponse_descr_.raw->forceomit); decoded_length = noteMS__GPRSPresentResponse().RAW_decode(NoteMS__GPRSPresentResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 22: { RAW_Force_Omit field_force_omit(22, force_omit, IdentificationRequest_descr_.raw->forceomit); decoded_length = identificationRequest().RAW_decode(IdentificationRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 23: { RAW_Force_Omit field_force_omit(23, force_omit, IdentificationResponse_descr_.raw->forceomit); decoded_length = identificationResponse().RAW_decode(IdentificationResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 24: { RAW_Force_Omit field_force_omit(24, force_omit, SGSN__ContextRequest_descr_.raw->forceomit); decoded_length = sgsn__ContextRequest().RAW_decode(SGSN__ContextRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 25: { RAW_Force_Omit field_force_omit(25, force_omit, SGSN__ContextResponse_descr_.raw->forceomit); decoded_length = sgsn__ContextResponse().RAW_decode(SGSN__ContextResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 26: { RAW_Force_Omit field_force_omit(26, force_omit, SGSN__ContextAcknowledge_descr_.raw->forceomit); decoded_length = sgsn__ContextAcknowledge().RAW_decode(SGSN__ContextAcknowledge_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 27: { RAW_Force_Omit field_force_omit(27, force_omit, ForwardRelocationRequest_descr_.raw->forceomit); decoded_length = forwardRelocationRequest().RAW_decode(ForwardRelocationRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 28: { RAW_Force_Omit field_force_omit(28, force_omit, ForwardRelocationResponse_descr_.raw->forceomit); decoded_length = forwardRelocationResponse().RAW_decode(ForwardRelocationResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 29: { RAW_Force_Omit field_force_omit(29, force_omit, ForwardRelocationComplete_descr_.raw->forceomit); decoded_length = forwardRelocationComplete().RAW_decode(ForwardRelocationComplete_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 30: { RAW_Force_Omit field_force_omit(30, force_omit, RelocationCancelRequest_descr_.raw->forceomit); decoded_length = relocationCancelRequest().RAW_decode(RelocationCancelRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 31: { RAW_Force_Omit field_force_omit(31, force_omit, RelocationCancelResponse_descr_.raw->forceomit); decoded_length = relocationCancelResponse().RAW_decode(RelocationCancelResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 32: { RAW_Force_Omit field_force_omit(32, force_omit, ForwardSRNSContext_descr_.raw->forceomit); decoded_length = forwardSRNSContext().RAW_decode(ForwardSRNSContext_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 33: { RAW_Force_Omit field_force_omit(33, force_omit, ForwardRelocationCompleteAcknowledge_descr_.raw->forceomit); decoded_length = forwardRelocationCompleteAcknowledge().RAW_decode(ForwardRelocationCompleteAcknowledge_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 34: { RAW_Force_Omit field_force_omit(34, force_omit, ForwardSRNSContextAcknowledge_descr_.raw->forceomit); decoded_length = forwardSRNSContextAcknowledge().RAW_decode(ForwardSRNSContextAcknowledge_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 35: { RAW_Force_Omit field_force_omit(35, force_omit, UERegistrationQueryRequest_descr_.raw->forceomit); decoded_length = uERegistrationQueryRequest().RAW_decode(UERegistrationQueryRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 36: { RAW_Force_Omit field_force_omit(36, force_omit, UERegistrationQueryResponse_descr_.raw->forceomit); decoded_length = uERegistrationQueryResponse().RAW_decode(UERegistrationQueryResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 37: { RAW_Force_Omit field_force_omit(37, force_omit, RANInformationRelay_descr_.raw->forceomit); decoded_length = ranInformationRelay().RAW_decode(RANInformationRelay_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 38: { RAW_Force_Omit field_force_omit(38, force_omit, MBMSNotificationRequest_descr_.raw->forceomit); decoded_length = mBMSNotificationRequest().RAW_decode(MBMSNotificationRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 39: { RAW_Force_Omit field_force_omit(39, force_omit, MBMSNotificationResponse_descr_.raw->forceomit); decoded_length = mBMSNotificationResponse().RAW_decode(MBMSNotificationResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 40: { RAW_Force_Omit field_force_omit(40, force_omit, MBMSNotificationRejectRequest_descr_.raw->forceomit); decoded_length = mBMSNotificationRejectRequest().RAW_decode(MBMSNotificationRejectRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 41: { RAW_Force_Omit field_force_omit(41, force_omit, MBMSNotificationRejectResponse_descr_.raw->forceomit); decoded_length = mBMSNotificationRejectResponse().RAW_decode(MBMSNotificationRejectResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 42: { RAW_Force_Omit field_force_omit(42, force_omit, CreateMBMSContextRequest_descr_.raw->forceomit); decoded_length = createMBMSContextRequest().RAW_decode(CreateMBMSContextRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 43: { RAW_Force_Omit field_force_omit(43, force_omit, CreateMBMSContextResponse_descr_.raw->forceomit); decoded_length = createMBMSContextResponse().RAW_decode(CreateMBMSContextResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 44: { RAW_Force_Omit field_force_omit(44, force_omit, UpdateMBMSContextRequest_descr_.raw->forceomit); decoded_length = updateMBMSContextRequest().RAW_decode(UpdateMBMSContextRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 45: { RAW_Force_Omit field_force_omit(45, force_omit, UpdateMBMSContextResponse_descr_.raw->forceomit); decoded_length = updateMBMSContextResponse().RAW_decode(UpdateMBMSContextResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 46: { RAW_Force_Omit field_force_omit(46, force_omit, DeleteMBMSContextRequest_descr_.raw->forceomit); decoded_length = deleteMBMSContextRequest().RAW_decode(DeleteMBMSContextRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 47: { RAW_Force_Omit field_force_omit(47, force_omit, DeleteMBMSContextResponse_descr_.raw->forceomit); decoded_length = deleteMBMSContextResponse().RAW_decode(DeleteMBMSContextResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 48: { RAW_Force_Omit field_force_omit(48, force_omit, MBMSRegistrationRequest__gtpc_descr_.raw->forceomit); decoded_length = mBMSRegistrationRequest().RAW_decode(MBMSRegistrationRequest__gtpc_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 49: { RAW_Force_Omit field_force_omit(49, force_omit, MBMSRegistrationResponse__gtpc_descr_.raw->forceomit); decoded_length = mBMSRegistrationResponse().RAW_decode(MBMSRegistrationResponse__gtpc_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 50: { RAW_Force_Omit field_force_omit(50, force_omit, MBMSDeRegistrationRequest_descr_.raw->forceomit); decoded_length = mBMSDeRegistrationRequest().RAW_decode(MBMSDeRegistrationRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 51: { RAW_Force_Omit field_force_omit(51, force_omit, MBMSDeRegistrationResponse_descr_.raw->forceomit); decoded_length = mBMSDeRegistrationResponse().RAW_decode(MBMSDeRegistrationResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 52: { RAW_Force_Omit field_force_omit(52, force_omit, MBMSSessionStartRequest_descr_.raw->forceomit); decoded_length = mBMSSessionStartRequest().RAW_decode(MBMSSessionStartRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 53: { RAW_Force_Omit field_force_omit(53, force_omit, MBMSSessionStartResponse__gtpc_descr_.raw->forceomit); decoded_length = mBMSSessionStartResponse().RAW_decode(MBMSSessionStartResponse__gtpc_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 54: { RAW_Force_Omit field_force_omit(54, force_omit, MBMSSessionStopRequest_descr_.raw->forceomit); decoded_length = mBMSSessionStopRequest().RAW_decode(MBMSSessionStopRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 55: { RAW_Force_Omit field_force_omit(55, force_omit, MBMSSessionStopResponse__gtpc_descr_.raw->forceomit); decoded_length = mBMSSessionStopResponse().RAW_decode(MBMSSessionStopResponse__gtpc_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 56: { RAW_Force_Omit field_force_omit(56, force_omit, MBMSSessionUpdateRequest_descr_.raw->forceomit); decoded_length = mBMSSessionUpdateRequest().RAW_decode(MBMSSessionUpdateRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 57: { RAW_Force_Omit field_force_omit(57, force_omit, MBMSSessionUpdateResponse_descr_.raw->forceomit); decoded_length = mBMSSessionUpdateResponse().RAW_decode(MBMSSessionUpdateResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 58: { RAW_Force_Omit field_force_omit(58, force_omit, MS__InfoChangeNotificationRequest_descr_.raw->forceomit); decoded_length = mS__InfoChangeNotificationRequest().RAW_decode(MS__InfoChangeNotificationRequest_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } case 59: { RAW_Force_Omit field_force_omit(59, force_omit, MS__InfoChangeNotificationResponse_descr_.raw->forceomit); decoded_length = mS__InfoChangeNotificationResponse().RAW_decode(MS__InfoChangeNotificationResponse_descr_, p_buf, limit, top_bit_ord, no_err, -1, TRUE, &field_force_omit); break; } default: break; } return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } else { p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_0_force_omit(0, force_omit, EchoRequest_descr_.raw->forceomit); decoded_length = echoRequest().RAW_decode(EchoRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_0_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_1_force_omit(1, force_omit, EchoResponse_descr_.raw->forceomit); decoded_length = echoResponse().RAW_decode(EchoResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_1_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_2_force_omit(2, force_omit, VersionNotSupported_descr_.raw->forceomit); decoded_length = versionNotSupported().RAW_decode(VersionNotSupported_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_2_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_3_force_omit(3, force_omit, CreatePDPContextRequest_descr_.raw->forceomit); decoded_length = createPDPContextRequest().RAW_decode(CreatePDPContextRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_3_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_4_force_omit(4, force_omit, CreatePDPContextResponse_descr_.raw->forceomit); decoded_length = createPDPContextResponse().RAW_decode(CreatePDPContextResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_4_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_5_force_omit(5, force_omit, UpdatePDPContextRequest_descr_.raw->forceomit); decoded_length = updatePDPContextRequest().RAW_decode(UpdatePDPContextRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_5_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_6_force_omit(6, force_omit, UpdatePDPContextResponse_descr_.raw->forceomit); decoded_length = updatePDPContextResponse().RAW_decode(UpdatePDPContextResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_6_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_7_force_omit(7, force_omit, DeletePDPContextRequest_descr_.raw->forceomit); decoded_length = deletePDPContextRequest().RAW_decode(DeletePDPContextRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_7_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_8_force_omit(8, force_omit, DeletePDPContextResponse_descr_.raw->forceomit); decoded_length = deletePDPContextResponse().RAW_decode(DeletePDPContextResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_8_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_9_force_omit(9, force_omit, PDU__NotificationRequest_descr_.raw->forceomit); decoded_length = pdu__NotificationRequest().RAW_decode(PDU__NotificationRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_9_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_10_force_omit(10, force_omit, PDU__NotificationResponse_descr_.raw->forceomit); decoded_length = pdu__NotificationResponse().RAW_decode(PDU__NotificationResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_10_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_11_force_omit(11, force_omit, PDU__NotificationRejectRequest_descr_.raw->forceomit); decoded_length = pdu__NotificationRejectRequest().RAW_decode(PDU__NotificationRejectRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_11_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_12_force_omit(12, force_omit, PDU__NotificationRejectResponse_descr_.raw->forceomit); decoded_length = pdu__NotificationRejectResponse().RAW_decode(PDU__NotificationRejectResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_12_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_13_force_omit(13, force_omit, InitiatePDPContextActivationRequest_descr_.raw->forceomit); decoded_length = initiatePDPContextActivationRequest().RAW_decode(InitiatePDPContextActivationRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_13_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_14_force_omit(14, force_omit, InitiatePDPContextActivationResponse_descr_.raw->forceomit); decoded_length = initiatePDPContextActivationResponse().RAW_decode(InitiatePDPContextActivationResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_14_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_15_force_omit(15, force_omit, SupportedExtensionHeadersNotification_descr_.raw->forceomit); decoded_length = supportedExtensionHeadersNotification().RAW_decode(SupportedExtensionHeadersNotification_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_15_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_16_force_omit(16, force_omit, SendRouteingInformationForGPRSRequest_descr_.raw->forceomit); decoded_length = sendRouteingInformationForGPRSRequest().RAW_decode(SendRouteingInformationForGPRSRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_16_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_17_force_omit(17, force_omit, SendRouteingInformationForGPRSResponse_descr_.raw->forceomit); decoded_length = sendRouteingInformationForGPRSResponse().RAW_decode(SendRouteingInformationForGPRSResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_17_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_18_force_omit(18, force_omit, FailureReportRequest_descr_.raw->forceomit); decoded_length = failureReportRequest().RAW_decode(FailureReportRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_18_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_19_force_omit(19, force_omit, FailureReportResponse_descr_.raw->forceomit); decoded_length = failureReportResponse().RAW_decode(FailureReportResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_19_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_20_force_omit(20, force_omit, NoteMS__GPRSPresentRequest_descr_.raw->forceomit); decoded_length = noteMS__GPRSPresentRequest().RAW_decode(NoteMS__GPRSPresentRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_20_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_21_force_omit(21, force_omit, NoteMS__GPRSPresentResponse_descr_.raw->forceomit); decoded_length = noteMS__GPRSPresentResponse().RAW_decode(NoteMS__GPRSPresentResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_21_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_22_force_omit(22, force_omit, IdentificationRequest_descr_.raw->forceomit); decoded_length = identificationRequest().RAW_decode(IdentificationRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_22_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_23_force_omit(23, force_omit, IdentificationResponse_descr_.raw->forceomit); decoded_length = identificationResponse().RAW_decode(IdentificationResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_23_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_24_force_omit(24, force_omit, SGSN__ContextRequest_descr_.raw->forceomit); decoded_length = sgsn__ContextRequest().RAW_decode(SGSN__ContextRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_24_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_25_force_omit(25, force_omit, SGSN__ContextResponse_descr_.raw->forceomit); decoded_length = sgsn__ContextResponse().RAW_decode(SGSN__ContextResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_25_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_26_force_omit(26, force_omit, SGSN__ContextAcknowledge_descr_.raw->forceomit); decoded_length = sgsn__ContextAcknowledge().RAW_decode(SGSN__ContextAcknowledge_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_26_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_27_force_omit(27, force_omit, ForwardRelocationRequest_descr_.raw->forceomit); decoded_length = forwardRelocationRequest().RAW_decode(ForwardRelocationRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_27_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_28_force_omit(28, force_omit, ForwardRelocationResponse_descr_.raw->forceomit); decoded_length = forwardRelocationResponse().RAW_decode(ForwardRelocationResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_28_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_29_force_omit(29, force_omit, ForwardRelocationComplete_descr_.raw->forceomit); decoded_length = forwardRelocationComplete().RAW_decode(ForwardRelocationComplete_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_29_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_30_force_omit(30, force_omit, RelocationCancelRequest_descr_.raw->forceomit); decoded_length = relocationCancelRequest().RAW_decode(RelocationCancelRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_30_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_31_force_omit(31, force_omit, RelocationCancelResponse_descr_.raw->forceomit); decoded_length = relocationCancelResponse().RAW_decode(RelocationCancelResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_31_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_32_force_omit(32, force_omit, ForwardSRNSContext_descr_.raw->forceomit); decoded_length = forwardSRNSContext().RAW_decode(ForwardSRNSContext_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_32_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_33_force_omit(33, force_omit, ForwardRelocationCompleteAcknowledge_descr_.raw->forceomit); decoded_length = forwardRelocationCompleteAcknowledge().RAW_decode(ForwardRelocationCompleteAcknowledge_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_33_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_34_force_omit(34, force_omit, ForwardSRNSContextAcknowledge_descr_.raw->forceomit); decoded_length = forwardSRNSContextAcknowledge().RAW_decode(ForwardSRNSContextAcknowledge_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_34_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_35_force_omit(35, force_omit, UERegistrationQueryRequest_descr_.raw->forceomit); decoded_length = uERegistrationQueryRequest().RAW_decode(UERegistrationQueryRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_35_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_36_force_omit(36, force_omit, UERegistrationQueryResponse_descr_.raw->forceomit); decoded_length = uERegistrationQueryResponse().RAW_decode(UERegistrationQueryResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_36_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_37_force_omit(37, force_omit, RANInformationRelay_descr_.raw->forceomit); decoded_length = ranInformationRelay().RAW_decode(RANInformationRelay_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_37_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_38_force_omit(38, force_omit, MBMSNotificationRequest_descr_.raw->forceomit); decoded_length = mBMSNotificationRequest().RAW_decode(MBMSNotificationRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_38_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_39_force_omit(39, force_omit, MBMSNotificationResponse_descr_.raw->forceomit); decoded_length = mBMSNotificationResponse().RAW_decode(MBMSNotificationResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_39_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_40_force_omit(40, force_omit, MBMSNotificationRejectRequest_descr_.raw->forceomit); decoded_length = mBMSNotificationRejectRequest().RAW_decode(MBMSNotificationRejectRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_40_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_41_force_omit(41, force_omit, MBMSNotificationRejectResponse_descr_.raw->forceomit); decoded_length = mBMSNotificationRejectResponse().RAW_decode(MBMSNotificationRejectResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_41_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_42_force_omit(42, force_omit, CreateMBMSContextRequest_descr_.raw->forceomit); decoded_length = createMBMSContextRequest().RAW_decode(CreateMBMSContextRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_42_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_43_force_omit(43, force_omit, CreateMBMSContextResponse_descr_.raw->forceomit); decoded_length = createMBMSContextResponse().RAW_decode(CreateMBMSContextResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_43_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_44_force_omit(44, force_omit, UpdateMBMSContextRequest_descr_.raw->forceomit); decoded_length = updateMBMSContextRequest().RAW_decode(UpdateMBMSContextRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_44_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_45_force_omit(45, force_omit, UpdateMBMSContextResponse_descr_.raw->forceomit); decoded_length = updateMBMSContextResponse().RAW_decode(UpdateMBMSContextResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_45_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_46_force_omit(46, force_omit, DeleteMBMSContextRequest_descr_.raw->forceomit); decoded_length = deleteMBMSContextRequest().RAW_decode(DeleteMBMSContextRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_46_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_47_force_omit(47, force_omit, DeleteMBMSContextResponse_descr_.raw->forceomit); decoded_length = deleteMBMSContextResponse().RAW_decode(DeleteMBMSContextResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_47_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_48_force_omit(48, force_omit, MBMSRegistrationRequest__gtpc_descr_.raw->forceomit); decoded_length = mBMSRegistrationRequest().RAW_decode(MBMSRegistrationRequest__gtpc_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_48_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_49_force_omit(49, force_omit, MBMSRegistrationResponse__gtpc_descr_.raw->forceomit); decoded_length = mBMSRegistrationResponse().RAW_decode(MBMSRegistrationResponse__gtpc_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_49_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_50_force_omit(50, force_omit, MBMSDeRegistrationRequest_descr_.raw->forceomit); decoded_length = mBMSDeRegistrationRequest().RAW_decode(MBMSDeRegistrationRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_50_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_51_force_omit(51, force_omit, MBMSDeRegistrationResponse_descr_.raw->forceomit); decoded_length = mBMSDeRegistrationResponse().RAW_decode(MBMSDeRegistrationResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_51_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_52_force_omit(52, force_omit, MBMSSessionStartRequest_descr_.raw->forceomit); decoded_length = mBMSSessionStartRequest().RAW_decode(MBMSSessionStartRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_52_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_53_force_omit(53, force_omit, MBMSSessionStartResponse__gtpc_descr_.raw->forceomit); decoded_length = mBMSSessionStartResponse().RAW_decode(MBMSSessionStartResponse__gtpc_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_53_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_54_force_omit(54, force_omit, MBMSSessionStopRequest_descr_.raw->forceomit); decoded_length = mBMSSessionStopRequest().RAW_decode(MBMSSessionStopRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_54_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_55_force_omit(55, force_omit, MBMSSessionStopResponse__gtpc_descr_.raw->forceomit); decoded_length = mBMSSessionStopResponse().RAW_decode(MBMSSessionStopResponse__gtpc_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_55_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_56_force_omit(56, force_omit, MBMSSessionUpdateRequest_descr_.raw->forceomit); decoded_length = mBMSSessionUpdateRequest().RAW_decode(MBMSSessionUpdateRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_56_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_57_force_omit(57, force_omit, MBMSSessionUpdateResponse_descr_.raw->forceomit); decoded_length = mBMSSessionUpdateResponse().RAW_decode(MBMSSessionUpdateResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_57_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_58_force_omit(58, force_omit, MS__InfoChangeNotificationRequest_descr_.raw->forceomit); decoded_length = mS__InfoChangeNotificationRequest().RAW_decode(MS__InfoChangeNotificationRequest_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_58_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } p_buf.set_pos_bit(starting_pos); RAW_Force_Omit field_59_force_omit(59, force_omit, MS__InfoChangeNotificationResponse_descr_.raw->forceomit); decoded_length = mS__InfoChangeNotificationResponse().RAW_decode(MS__InfoChangeNotificationResponse_descr_, p_buf, limit, top_bit_ord, TRUE, -1, TRUE, &field_59_force_omit); if (decoded_length >= 0) { return decoded_length + p_buf.increase_pos_padd(p_td.raw->padding) + prepaddlength; } } clean_up(); return -1; } int GTPC__PDUs::RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree& myleaf) const { int encoded_length = 0; myleaf.isleaf = FALSE; myleaf.body.node.num_of_nodes = 60; myleaf.body.node.nodes = init_nodes_of_enc_tree(60); memset(myleaf.body.node.nodes, 0, 60 * sizeof(RAW_enc_tree *)); switch (union_selection) { case ALT_echoRequest: myleaf.body.node.nodes[0] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 0, EchoRequest_descr_.raw); encoded_length = field_echoRequest->RAW_encode(EchoRequest_descr_, *myleaf.body.node.nodes[0]); myleaf.body.node.nodes[0]->coding_descr = &EchoRequest_descr_; break; case ALT_echoResponse: myleaf.body.node.nodes[1] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 1, EchoResponse_descr_.raw); encoded_length = field_echoResponse->RAW_encode(EchoResponse_descr_, *myleaf.body.node.nodes[1]); myleaf.body.node.nodes[1]->coding_descr = &EchoResponse_descr_; break; case ALT_versionNotSupported: myleaf.body.node.nodes[2] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 2, VersionNotSupported_descr_.raw); encoded_length = field_versionNotSupported->RAW_encode(VersionNotSupported_descr_, *myleaf.body.node.nodes[2]); myleaf.body.node.nodes[2]->coding_descr = &VersionNotSupported_descr_; break; case ALT_createPDPContextRequest: myleaf.body.node.nodes[3] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 3, CreatePDPContextRequest_descr_.raw); encoded_length = field_createPDPContextRequest->RAW_encode(CreatePDPContextRequest_descr_, *myleaf.body.node.nodes[3]); myleaf.body.node.nodes[3]->coding_descr = &CreatePDPContextRequest_descr_; break; case ALT_createPDPContextResponse: myleaf.body.node.nodes[4] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 4, CreatePDPContextResponse_descr_.raw); encoded_length = field_createPDPContextResponse->RAW_encode(CreatePDPContextResponse_descr_, *myleaf.body.node.nodes[4]); myleaf.body.node.nodes[4]->coding_descr = &CreatePDPContextResponse_descr_; break; case ALT_updatePDPContextRequest: myleaf.body.node.nodes[5] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 5, UpdatePDPContextRequest_descr_.raw); encoded_length = field_updatePDPContextRequest->RAW_encode(UpdatePDPContextRequest_descr_, *myleaf.body.node.nodes[5]); myleaf.body.node.nodes[5]->coding_descr = &UpdatePDPContextRequest_descr_; break; case ALT_updatePDPContextResponse: myleaf.body.node.nodes[6] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 6, UpdatePDPContextResponse_descr_.raw); encoded_length = field_updatePDPContextResponse->RAW_encode(UpdatePDPContextResponse_descr_, *myleaf.body.node.nodes[6]); myleaf.body.node.nodes[6]->coding_descr = &UpdatePDPContextResponse_descr_; break; case ALT_deletePDPContextRequest: myleaf.body.node.nodes[7] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 7, DeletePDPContextRequest_descr_.raw); encoded_length = field_deletePDPContextRequest->RAW_encode(DeletePDPContextRequest_descr_, *myleaf.body.node.nodes[7]); myleaf.body.node.nodes[7]->coding_descr = &DeletePDPContextRequest_descr_; break; case ALT_deletePDPContextResponse: myleaf.body.node.nodes[8] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 8, DeletePDPContextResponse_descr_.raw); encoded_length = field_deletePDPContextResponse->RAW_encode(DeletePDPContextResponse_descr_, *myleaf.body.node.nodes[8]); myleaf.body.node.nodes[8]->coding_descr = &DeletePDPContextResponse_descr_; break; case ALT_pdu__NotificationRequest: myleaf.body.node.nodes[9] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 9, PDU__NotificationRequest_descr_.raw); encoded_length = field_pdu__NotificationRequest->RAW_encode(PDU__NotificationRequest_descr_, *myleaf.body.node.nodes[9]); myleaf.body.node.nodes[9]->coding_descr = &PDU__NotificationRequest_descr_; break; case ALT_pdu__NotificationResponse: myleaf.body.node.nodes[10] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 10, PDU__NotificationResponse_descr_.raw); encoded_length = field_pdu__NotificationResponse->RAW_encode(PDU__NotificationResponse_descr_, *myleaf.body.node.nodes[10]); myleaf.body.node.nodes[10]->coding_descr = &PDU__NotificationResponse_descr_; break; case ALT_pdu__NotificationRejectRequest: myleaf.body.node.nodes[11] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 11, PDU__NotificationRejectRequest_descr_.raw); encoded_length = field_pdu__NotificationRejectRequest->RAW_encode(PDU__NotificationRejectRequest_descr_, *myleaf.body.node.nodes[11]); myleaf.body.node.nodes[11]->coding_descr = &PDU__NotificationRejectRequest_descr_; break; case ALT_pdu__NotificationRejectResponse: myleaf.body.node.nodes[12] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 12, PDU__NotificationRejectResponse_descr_.raw); encoded_length = field_pdu__NotificationRejectResponse->RAW_encode(PDU__NotificationRejectResponse_descr_, *myleaf.body.node.nodes[12]); myleaf.body.node.nodes[12]->coding_descr = &PDU__NotificationRejectResponse_descr_; break; case ALT_initiatePDPContextActivationRequest: myleaf.body.node.nodes[13] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 13, InitiatePDPContextActivationRequest_descr_.raw); encoded_length = field_initiatePDPContextActivationRequest->RAW_encode(InitiatePDPContextActivationRequest_descr_, *myleaf.body.node.nodes[13]); myleaf.body.node.nodes[13]->coding_descr = &InitiatePDPContextActivationRequest_descr_; break; case ALT_initiatePDPContextActivationResponse: myleaf.body.node.nodes[14] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 14, InitiatePDPContextActivationResponse_descr_.raw); encoded_length = field_initiatePDPContextActivationResponse->RAW_encode(InitiatePDPContextActivationResponse_descr_, *myleaf.body.node.nodes[14]); myleaf.body.node.nodes[14]->coding_descr = &InitiatePDPContextActivationResponse_descr_; break; case ALT_supportedExtensionHeadersNotification: myleaf.body.node.nodes[15] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 15, SupportedExtensionHeadersNotification_descr_.raw); encoded_length = field_supportedExtensionHeadersNotification->RAW_encode(SupportedExtensionHeadersNotification_descr_, *myleaf.body.node.nodes[15]); myleaf.body.node.nodes[15]->coding_descr = &SupportedExtensionHeadersNotification_descr_; break; case ALT_sendRouteingInformationForGPRSRequest: myleaf.body.node.nodes[16] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 16, SendRouteingInformationForGPRSRequest_descr_.raw); encoded_length = field_sendRouteingInformationForGPRSRequest->RAW_encode(SendRouteingInformationForGPRSRequest_descr_, *myleaf.body.node.nodes[16]); myleaf.body.node.nodes[16]->coding_descr = &SendRouteingInformationForGPRSRequest_descr_; break; case ALT_sendRouteingInformationForGPRSResponse: myleaf.body.node.nodes[17] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 17, SendRouteingInformationForGPRSResponse_descr_.raw); encoded_length = field_sendRouteingInformationForGPRSResponse->RAW_encode(SendRouteingInformationForGPRSResponse_descr_, *myleaf.body.node.nodes[17]); myleaf.body.node.nodes[17]->coding_descr = &SendRouteingInformationForGPRSResponse_descr_; break; case ALT_failureReportRequest: myleaf.body.node.nodes[18] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 18, FailureReportRequest_descr_.raw); encoded_length = field_failureReportRequest->RAW_encode(FailureReportRequest_descr_, *myleaf.body.node.nodes[18]); myleaf.body.node.nodes[18]->coding_descr = &FailureReportRequest_descr_; break; case ALT_failureReportResponse: myleaf.body.node.nodes[19] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 19, FailureReportResponse_descr_.raw); encoded_length = field_failureReportResponse->RAW_encode(FailureReportResponse_descr_, *myleaf.body.node.nodes[19]); myleaf.body.node.nodes[19]->coding_descr = &FailureReportResponse_descr_; break; case ALT_noteMS__GPRSPresentRequest: myleaf.body.node.nodes[20] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 20, NoteMS__GPRSPresentRequest_descr_.raw); encoded_length = field_noteMS__GPRSPresentRequest->RAW_encode(NoteMS__GPRSPresentRequest_descr_, *myleaf.body.node.nodes[20]); myleaf.body.node.nodes[20]->coding_descr = &NoteMS__GPRSPresentRequest_descr_; break; case ALT_noteMS__GPRSPresentResponse: myleaf.body.node.nodes[21] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 21, NoteMS__GPRSPresentResponse_descr_.raw); encoded_length = field_noteMS__GPRSPresentResponse->RAW_encode(NoteMS__GPRSPresentResponse_descr_, *myleaf.body.node.nodes[21]); myleaf.body.node.nodes[21]->coding_descr = &NoteMS__GPRSPresentResponse_descr_; break; case ALT_identificationRequest: myleaf.body.node.nodes[22] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 22, IdentificationRequest_descr_.raw); encoded_length = field_identificationRequest->RAW_encode(IdentificationRequest_descr_, *myleaf.body.node.nodes[22]); myleaf.body.node.nodes[22]->coding_descr = &IdentificationRequest_descr_; break; case ALT_identificationResponse: myleaf.body.node.nodes[23] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 23, IdentificationResponse_descr_.raw); encoded_length = field_identificationResponse->RAW_encode(IdentificationResponse_descr_, *myleaf.body.node.nodes[23]); myleaf.body.node.nodes[23]->coding_descr = &IdentificationResponse_descr_; break; case ALT_sgsn__ContextRequest: myleaf.body.node.nodes[24] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 24, SGSN__ContextRequest_descr_.raw); encoded_length = field_sgsn__ContextRequest->RAW_encode(SGSN__ContextRequest_descr_, *myleaf.body.node.nodes[24]); myleaf.body.node.nodes[24]->coding_descr = &SGSN__ContextRequest_descr_; break; case ALT_sgsn__ContextResponse: myleaf.body.node.nodes[25] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 25, SGSN__ContextResponse_descr_.raw); encoded_length = field_sgsn__ContextResponse->RAW_encode(SGSN__ContextResponse_descr_, *myleaf.body.node.nodes[25]); myleaf.body.node.nodes[25]->coding_descr = &SGSN__ContextResponse_descr_; break; case ALT_sgsn__ContextAcknowledge: myleaf.body.node.nodes[26] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 26, SGSN__ContextAcknowledge_descr_.raw); encoded_length = field_sgsn__ContextAcknowledge->RAW_encode(SGSN__ContextAcknowledge_descr_, *myleaf.body.node.nodes[26]); myleaf.body.node.nodes[26]->coding_descr = &SGSN__ContextAcknowledge_descr_; break; case ALT_forwardRelocationRequest: myleaf.body.node.nodes[27] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 27, ForwardRelocationRequest_descr_.raw); encoded_length = field_forwardRelocationRequest->RAW_encode(ForwardRelocationRequest_descr_, *myleaf.body.node.nodes[27]); myleaf.body.node.nodes[27]->coding_descr = &ForwardRelocationRequest_descr_; break; case ALT_forwardRelocationResponse: myleaf.body.node.nodes[28] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 28, ForwardRelocationResponse_descr_.raw); encoded_length = field_forwardRelocationResponse->RAW_encode(ForwardRelocationResponse_descr_, *myleaf.body.node.nodes[28]); myleaf.body.node.nodes[28]->coding_descr = &ForwardRelocationResponse_descr_; break; case ALT_forwardRelocationComplete: myleaf.body.node.nodes[29] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 29, ForwardRelocationComplete_descr_.raw); encoded_length = field_forwardRelocationComplete->RAW_encode(ForwardRelocationComplete_descr_, *myleaf.body.node.nodes[29]); myleaf.body.node.nodes[29]->coding_descr = &ForwardRelocationComplete_descr_; break; case ALT_relocationCancelRequest: myleaf.body.node.nodes[30] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 30, RelocationCancelRequest_descr_.raw); encoded_length = field_relocationCancelRequest->RAW_encode(RelocationCancelRequest_descr_, *myleaf.body.node.nodes[30]); myleaf.body.node.nodes[30]->coding_descr = &RelocationCancelRequest_descr_; break; case ALT_relocationCancelResponse: myleaf.body.node.nodes[31] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 31, RelocationCancelResponse_descr_.raw); encoded_length = field_relocationCancelResponse->RAW_encode(RelocationCancelResponse_descr_, *myleaf.body.node.nodes[31]); myleaf.body.node.nodes[31]->coding_descr = &RelocationCancelResponse_descr_; break; case ALT_forwardSRNSContext: myleaf.body.node.nodes[32] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 32, ForwardSRNSContext_descr_.raw); encoded_length = field_forwardSRNSContext->RAW_encode(ForwardSRNSContext_descr_, *myleaf.body.node.nodes[32]); myleaf.body.node.nodes[32]->coding_descr = &ForwardSRNSContext_descr_; break; case ALT_forwardRelocationCompleteAcknowledge: myleaf.body.node.nodes[33] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 33, ForwardRelocationCompleteAcknowledge_descr_.raw); encoded_length = field_forwardRelocationCompleteAcknowledge->RAW_encode(ForwardRelocationCompleteAcknowledge_descr_, *myleaf.body.node.nodes[33]); myleaf.body.node.nodes[33]->coding_descr = &ForwardRelocationCompleteAcknowledge_descr_; break; case ALT_forwardSRNSContextAcknowledge: myleaf.body.node.nodes[34] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 34, ForwardSRNSContextAcknowledge_descr_.raw); encoded_length = field_forwardSRNSContextAcknowledge->RAW_encode(ForwardSRNSContextAcknowledge_descr_, *myleaf.body.node.nodes[34]); myleaf.body.node.nodes[34]->coding_descr = &ForwardSRNSContextAcknowledge_descr_; break; case ALT_uERegistrationQueryRequest: myleaf.body.node.nodes[35] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 35, UERegistrationQueryRequest_descr_.raw); encoded_length = field_uERegistrationQueryRequest->RAW_encode(UERegistrationQueryRequest_descr_, *myleaf.body.node.nodes[35]); myleaf.body.node.nodes[35]->coding_descr = &UERegistrationQueryRequest_descr_; break; case ALT_uERegistrationQueryResponse: myleaf.body.node.nodes[36] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 36, UERegistrationQueryResponse_descr_.raw); encoded_length = field_uERegistrationQueryResponse->RAW_encode(UERegistrationQueryResponse_descr_, *myleaf.body.node.nodes[36]); myleaf.body.node.nodes[36]->coding_descr = &UERegistrationQueryResponse_descr_; break; case ALT_ranInformationRelay: myleaf.body.node.nodes[37] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 37, RANInformationRelay_descr_.raw); encoded_length = field_ranInformationRelay->RAW_encode(RANInformationRelay_descr_, *myleaf.body.node.nodes[37]); myleaf.body.node.nodes[37]->coding_descr = &RANInformationRelay_descr_; break; case ALT_mBMSNotificationRequest: myleaf.body.node.nodes[38] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 38, MBMSNotificationRequest_descr_.raw); encoded_length = field_mBMSNotificationRequest->RAW_encode(MBMSNotificationRequest_descr_, *myleaf.body.node.nodes[38]); myleaf.body.node.nodes[38]->coding_descr = &MBMSNotificationRequest_descr_; break; case ALT_mBMSNotificationResponse: myleaf.body.node.nodes[39] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 39, MBMSNotificationResponse_descr_.raw); encoded_length = field_mBMSNotificationResponse->RAW_encode(MBMSNotificationResponse_descr_, *myleaf.body.node.nodes[39]); myleaf.body.node.nodes[39]->coding_descr = &MBMSNotificationResponse_descr_; break; case ALT_mBMSNotificationRejectRequest: myleaf.body.node.nodes[40] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 40, MBMSNotificationRejectRequest_descr_.raw); encoded_length = field_mBMSNotificationRejectRequest->RAW_encode(MBMSNotificationRejectRequest_descr_, *myleaf.body.node.nodes[40]); myleaf.body.node.nodes[40]->coding_descr = &MBMSNotificationRejectRequest_descr_; break; case ALT_mBMSNotificationRejectResponse: myleaf.body.node.nodes[41] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 41, MBMSNotificationRejectResponse_descr_.raw); encoded_length = field_mBMSNotificationRejectResponse->RAW_encode(MBMSNotificationRejectResponse_descr_, *myleaf.body.node.nodes[41]); myleaf.body.node.nodes[41]->coding_descr = &MBMSNotificationRejectResponse_descr_; break; case ALT_createMBMSContextRequest: myleaf.body.node.nodes[42] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 42, CreateMBMSContextRequest_descr_.raw); encoded_length = field_createMBMSContextRequest->RAW_encode(CreateMBMSContextRequest_descr_, *myleaf.body.node.nodes[42]); myleaf.body.node.nodes[42]->coding_descr = &CreateMBMSContextRequest_descr_; break; case ALT_createMBMSContextResponse: myleaf.body.node.nodes[43] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 43, CreateMBMSContextResponse_descr_.raw); encoded_length = field_createMBMSContextResponse->RAW_encode(CreateMBMSContextResponse_descr_, *myleaf.body.node.nodes[43]); myleaf.body.node.nodes[43]->coding_descr = &CreateMBMSContextResponse_descr_; break; case ALT_updateMBMSContextRequest: myleaf.body.node.nodes[44] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 44, UpdateMBMSContextRequest_descr_.raw); encoded_length = field_updateMBMSContextRequest->RAW_encode(UpdateMBMSContextRequest_descr_, *myleaf.body.node.nodes[44]); myleaf.body.node.nodes[44]->coding_descr = &UpdateMBMSContextRequest_descr_; break; case ALT_updateMBMSContextResponse: myleaf.body.node.nodes[45] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 45, UpdateMBMSContextResponse_descr_.raw); encoded_length = field_updateMBMSContextResponse->RAW_encode(UpdateMBMSContextResponse_descr_, *myleaf.body.node.nodes[45]); myleaf.body.node.nodes[45]->coding_descr = &UpdateMBMSContextResponse_descr_; break; case ALT_deleteMBMSContextRequest: myleaf.body.node.nodes[46] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 46, DeleteMBMSContextRequest_descr_.raw); encoded_length = field_deleteMBMSContextRequest->RAW_encode(DeleteMBMSContextRequest_descr_, *myleaf.body.node.nodes[46]); myleaf.body.node.nodes[46]->coding_descr = &DeleteMBMSContextRequest_descr_; break; case ALT_deleteMBMSContextResponse: myleaf.body.node.nodes[47] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 47, DeleteMBMSContextResponse_descr_.raw); encoded_length = field_deleteMBMSContextResponse->RAW_encode(DeleteMBMSContextResponse_descr_, *myleaf.body.node.nodes[47]); myleaf.body.node.nodes[47]->coding_descr = &DeleteMBMSContextResponse_descr_; break; case ALT_mBMSRegistrationRequest: myleaf.body.node.nodes[48] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 48, MBMSRegistrationRequest__gtpc_descr_.raw); encoded_length = field_mBMSRegistrationRequest->RAW_encode(MBMSRegistrationRequest__gtpc_descr_, *myleaf.body.node.nodes[48]); myleaf.body.node.nodes[48]->coding_descr = &MBMSRegistrationRequest__gtpc_descr_; break; case ALT_mBMSRegistrationResponse: myleaf.body.node.nodes[49] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 49, MBMSRegistrationResponse__gtpc_descr_.raw); encoded_length = field_mBMSRegistrationResponse->RAW_encode(MBMSRegistrationResponse__gtpc_descr_, *myleaf.body.node.nodes[49]); myleaf.body.node.nodes[49]->coding_descr = &MBMSRegistrationResponse__gtpc_descr_; break; case ALT_mBMSDeRegistrationRequest: myleaf.body.node.nodes[50] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 50, MBMSDeRegistrationRequest_descr_.raw); encoded_length = field_mBMSDeRegistrationRequest->RAW_encode(MBMSDeRegistrationRequest_descr_, *myleaf.body.node.nodes[50]); myleaf.body.node.nodes[50]->coding_descr = &MBMSDeRegistrationRequest_descr_; break; case ALT_mBMSDeRegistrationResponse: myleaf.body.node.nodes[51] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 51, MBMSDeRegistrationResponse_descr_.raw); encoded_length = field_mBMSDeRegistrationResponse->RAW_encode(MBMSDeRegistrationResponse_descr_, *myleaf.body.node.nodes[51]); myleaf.body.node.nodes[51]->coding_descr = &MBMSDeRegistrationResponse_descr_; break; case ALT_mBMSSessionStartRequest: myleaf.body.node.nodes[52] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 52, MBMSSessionStartRequest_descr_.raw); encoded_length = field_mBMSSessionStartRequest->RAW_encode(MBMSSessionStartRequest_descr_, *myleaf.body.node.nodes[52]); myleaf.body.node.nodes[52]->coding_descr = &MBMSSessionStartRequest_descr_; break; case ALT_mBMSSessionStartResponse: myleaf.body.node.nodes[53] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 53, MBMSSessionStartResponse__gtpc_descr_.raw); encoded_length = field_mBMSSessionStartResponse->RAW_encode(MBMSSessionStartResponse__gtpc_descr_, *myleaf.body.node.nodes[53]); myleaf.body.node.nodes[53]->coding_descr = &MBMSSessionStartResponse__gtpc_descr_; break; case ALT_mBMSSessionStopRequest: myleaf.body.node.nodes[54] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 54, MBMSSessionStopRequest_descr_.raw); encoded_length = field_mBMSSessionStopRequest->RAW_encode(MBMSSessionStopRequest_descr_, *myleaf.body.node.nodes[54]); myleaf.body.node.nodes[54]->coding_descr = &MBMSSessionStopRequest_descr_; break; case ALT_mBMSSessionStopResponse: myleaf.body.node.nodes[55] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 55, MBMSSessionStopResponse__gtpc_descr_.raw); encoded_length = field_mBMSSessionStopResponse->RAW_encode(MBMSSessionStopResponse__gtpc_descr_, *myleaf.body.node.nodes[55]); myleaf.body.node.nodes[55]->coding_descr = &MBMSSessionStopResponse__gtpc_descr_; break; case ALT_mBMSSessionUpdateRequest: myleaf.body.node.nodes[56] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 56, MBMSSessionUpdateRequest_descr_.raw); encoded_length = field_mBMSSessionUpdateRequest->RAW_encode(MBMSSessionUpdateRequest_descr_, *myleaf.body.node.nodes[56]); myleaf.body.node.nodes[56]->coding_descr = &MBMSSessionUpdateRequest_descr_; break; case ALT_mBMSSessionUpdateResponse: myleaf.body.node.nodes[57] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 57, MBMSSessionUpdateResponse_descr_.raw); encoded_length = field_mBMSSessionUpdateResponse->RAW_encode(MBMSSessionUpdateResponse_descr_, *myleaf.body.node.nodes[57]); myleaf.body.node.nodes[57]->coding_descr = &MBMSSessionUpdateResponse_descr_; break; case ALT_mS__InfoChangeNotificationRequest: myleaf.body.node.nodes[58] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 58, MS__InfoChangeNotificationRequest_descr_.raw); encoded_length = field_mS__InfoChangeNotificationRequest->RAW_encode(MS__InfoChangeNotificationRequest_descr_, *myleaf.body.node.nodes[58]); myleaf.body.node.nodes[58]->coding_descr = &MS__InfoChangeNotificationRequest_descr_; break; case ALT_mS__InfoChangeNotificationResponse: myleaf.body.node.nodes[59] = new RAW_enc_tree(TRUE, &myleaf, &myleaf.curr_pos, 59, MS__InfoChangeNotificationResponse_descr_.raw); encoded_length = field_mS__InfoChangeNotificationResponse->RAW_encode(MS__InfoChangeNotificationResponse_descr_, *myleaf.body.node.nodes[59]); myleaf.body.node.nodes[59]->coding_descr = &MS__InfoChangeNotificationResponse_descr_; break; default: TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_UNBOUND, "Encoding an unbound value."); } return encoded_length; } void GTPC__PDUs_template::copy_value(const GTPC__PDUs& other_value) { single_value.union_selection = other_value.get_selection(); switch (single_value.union_selection) { case GTPC__PDUs::ALT_echoRequest: single_value.field_echoRequest = new EchoRequest_template(other_value.echoRequest()); break; case GTPC__PDUs::ALT_echoResponse: single_value.field_echoResponse = new EchoResponse_template(other_value.echoResponse()); break; case GTPC__PDUs::ALT_versionNotSupported: single_value.field_versionNotSupported = new VersionNotSupported_template(other_value.versionNotSupported()); break; case GTPC__PDUs::ALT_createPDPContextRequest: single_value.field_createPDPContextRequest = new CreatePDPContextRequest_template(other_value.createPDPContextRequest()); break; case GTPC__PDUs::ALT_createPDPContextResponse: single_value.field_createPDPContextResponse = new CreatePDPContextResponse_template(other_value.createPDPContextResponse()); break; case GTPC__PDUs::ALT_updatePDPContextRequest: single_value.field_updatePDPContextRequest = new UpdatePDPContextRequest_template(other_value.updatePDPContextRequest()); break; case GTPC__PDUs::ALT_updatePDPContextResponse: single_value.field_updatePDPContextResponse = new UpdatePDPContextResponse_template(other_value.updatePDPContextResponse()); break; case GTPC__PDUs::ALT_deletePDPContextRequest: single_value.field_deletePDPContextRequest = new DeletePDPContextRequest_template(other_value.deletePDPContextRequest()); break; case GTPC__PDUs::ALT_deletePDPContextResponse: single_value.field_deletePDPContextResponse = new DeletePDPContextResponse_template(other_value.deletePDPContextResponse()); break; case GTPC__PDUs::ALT_pdu__NotificationRequest: single_value.field_pdu__NotificationRequest = new PDU__NotificationRequest_template(other_value.pdu__NotificationRequest()); break; case GTPC__PDUs::ALT_pdu__NotificationResponse: single_value.field_pdu__NotificationResponse = new PDU__NotificationResponse_template(other_value.pdu__NotificationResponse()); break; case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: single_value.field_pdu__NotificationRejectRequest = new PDU__NotificationRejectRequest_template(other_value.pdu__NotificationRejectRequest()); break; case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: single_value.field_pdu__NotificationRejectResponse = new PDU__NotificationRejectResponse_template(other_value.pdu__NotificationRejectResponse()); break; case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: single_value.field_initiatePDPContextActivationRequest = new InitiatePDPContextActivationRequest_template(other_value.initiatePDPContextActivationRequest()); break; case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: single_value.field_initiatePDPContextActivationResponse = new InitiatePDPContextActivationResponse_template(other_value.initiatePDPContextActivationResponse()); break; case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: single_value.field_supportedExtensionHeadersNotification = new SupportedExtensionHeadersNotification_template(other_value.supportedExtensionHeadersNotification()); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: single_value.field_sendRouteingInformationForGPRSRequest = new SendRouteingInformationForGPRSRequest_template(other_value.sendRouteingInformationForGPRSRequest()); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: single_value.field_sendRouteingInformationForGPRSResponse = new SendRouteingInformationForGPRSResponse_template(other_value.sendRouteingInformationForGPRSResponse()); break; case GTPC__PDUs::ALT_failureReportRequest: single_value.field_failureReportRequest = new FailureReportRequest_template(other_value.failureReportRequest()); break; case GTPC__PDUs::ALT_failureReportResponse: single_value.field_failureReportResponse = new FailureReportResponse_template(other_value.failureReportResponse()); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: single_value.field_noteMS__GPRSPresentRequest = new NoteMS__GPRSPresentRequest_template(other_value.noteMS__GPRSPresentRequest()); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: single_value.field_noteMS__GPRSPresentResponse = new NoteMS__GPRSPresentResponse_template(other_value.noteMS__GPRSPresentResponse()); break; case GTPC__PDUs::ALT_identificationRequest: single_value.field_identificationRequest = new IdentificationRequest_template(other_value.identificationRequest()); break; case GTPC__PDUs::ALT_identificationResponse: single_value.field_identificationResponse = new IdentificationResponse_template(other_value.identificationResponse()); break; case GTPC__PDUs::ALT_sgsn__ContextRequest: single_value.field_sgsn__ContextRequest = new SGSN__ContextRequest_template(other_value.sgsn__ContextRequest()); break; case GTPC__PDUs::ALT_sgsn__ContextResponse: single_value.field_sgsn__ContextResponse = new SGSN__ContextResponse_template(other_value.sgsn__ContextResponse()); break; case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: single_value.field_sgsn__ContextAcknowledge = new SGSN__ContextAcknowledge_template(other_value.sgsn__ContextAcknowledge()); break; case GTPC__PDUs::ALT_forwardRelocationRequest: single_value.field_forwardRelocationRequest = new ForwardRelocationRequest_template(other_value.forwardRelocationRequest()); break; case GTPC__PDUs::ALT_forwardRelocationResponse: single_value.field_forwardRelocationResponse = new ForwardRelocationResponse_template(other_value.forwardRelocationResponse()); break; case GTPC__PDUs::ALT_forwardRelocationComplete: single_value.field_forwardRelocationComplete = new ForwardRelocationComplete_template(other_value.forwardRelocationComplete()); break; case GTPC__PDUs::ALT_relocationCancelRequest: single_value.field_relocationCancelRequest = new RelocationCancelRequest_template(other_value.relocationCancelRequest()); break; case GTPC__PDUs::ALT_relocationCancelResponse: single_value.field_relocationCancelResponse = new RelocationCancelResponse_template(other_value.relocationCancelResponse()); break; case GTPC__PDUs::ALT_forwardSRNSContext: single_value.field_forwardSRNSContext = new ForwardSRNSContext_template(other_value.forwardSRNSContext()); break; case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: single_value.field_forwardRelocationCompleteAcknowledge = new ForwardRelocationCompleteAcknowledge_template(other_value.forwardRelocationCompleteAcknowledge()); break; case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: single_value.field_forwardSRNSContextAcknowledge = new ForwardSRNSContextAcknowledge_template(other_value.forwardSRNSContextAcknowledge()); break; case GTPC__PDUs::ALT_uERegistrationQueryRequest: single_value.field_uERegistrationQueryRequest = new UERegistrationQueryRequest_template(other_value.uERegistrationQueryRequest()); break; case GTPC__PDUs::ALT_uERegistrationQueryResponse: single_value.field_uERegistrationQueryResponse = new UERegistrationQueryResponse_template(other_value.uERegistrationQueryResponse()); break; case GTPC__PDUs::ALT_ranInformationRelay: single_value.field_ranInformationRelay = new RANInformationRelay_template(other_value.ranInformationRelay()); break; case GTPC__PDUs::ALT_mBMSNotificationRequest: single_value.field_mBMSNotificationRequest = new MBMSNotificationRequest_template(other_value.mBMSNotificationRequest()); break; case GTPC__PDUs::ALT_mBMSNotificationResponse: single_value.field_mBMSNotificationResponse = new MBMSNotificationResponse_template(other_value.mBMSNotificationResponse()); break; case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: single_value.field_mBMSNotificationRejectRequest = new MBMSNotificationRejectRequest_template(other_value.mBMSNotificationRejectRequest()); break; case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: single_value.field_mBMSNotificationRejectResponse = new MBMSNotificationRejectResponse_template(other_value.mBMSNotificationRejectResponse()); break; case GTPC__PDUs::ALT_createMBMSContextRequest: single_value.field_createMBMSContextRequest = new CreateMBMSContextRequest_template(other_value.createMBMSContextRequest()); break; case GTPC__PDUs::ALT_createMBMSContextResponse: single_value.field_createMBMSContextResponse = new CreateMBMSContextResponse_template(other_value.createMBMSContextResponse()); break; case GTPC__PDUs::ALT_updateMBMSContextRequest: single_value.field_updateMBMSContextRequest = new UpdateMBMSContextRequest_template(other_value.updateMBMSContextRequest()); break; case GTPC__PDUs::ALT_updateMBMSContextResponse: single_value.field_updateMBMSContextResponse = new UpdateMBMSContextResponse_template(other_value.updateMBMSContextResponse()); break; case GTPC__PDUs::ALT_deleteMBMSContextRequest: single_value.field_deleteMBMSContextRequest = new DeleteMBMSContextRequest_template(other_value.deleteMBMSContextRequest()); break; case GTPC__PDUs::ALT_deleteMBMSContextResponse: single_value.field_deleteMBMSContextResponse = new DeleteMBMSContextResponse_template(other_value.deleteMBMSContextResponse()); break; case GTPC__PDUs::ALT_mBMSRegistrationRequest: single_value.field_mBMSRegistrationRequest = new MBMSRegistrationRequest__gtpc_template(other_value.mBMSRegistrationRequest()); break; case GTPC__PDUs::ALT_mBMSRegistrationResponse: single_value.field_mBMSRegistrationResponse = new MBMSRegistrationResponse__gtpc_template(other_value.mBMSRegistrationResponse()); break; case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: single_value.field_mBMSDeRegistrationRequest = new MBMSDeRegistrationRequest_template(other_value.mBMSDeRegistrationRequest()); break; case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: single_value.field_mBMSDeRegistrationResponse = new MBMSDeRegistrationResponse_template(other_value.mBMSDeRegistrationResponse()); break; case GTPC__PDUs::ALT_mBMSSessionStartRequest: single_value.field_mBMSSessionStartRequest = new MBMSSessionStartRequest_template(other_value.mBMSSessionStartRequest()); break; case GTPC__PDUs::ALT_mBMSSessionStartResponse: single_value.field_mBMSSessionStartResponse = new MBMSSessionStartResponse__gtpc_template(other_value.mBMSSessionStartResponse()); break; case GTPC__PDUs::ALT_mBMSSessionStopRequest: single_value.field_mBMSSessionStopRequest = new MBMSSessionStopRequest_template(other_value.mBMSSessionStopRequest()); break; case GTPC__PDUs::ALT_mBMSSessionStopResponse: single_value.field_mBMSSessionStopResponse = new MBMSSessionStopResponse__gtpc_template(other_value.mBMSSessionStopResponse()); break; case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: single_value.field_mBMSSessionUpdateRequest = new MBMSSessionUpdateRequest_template(other_value.mBMSSessionUpdateRequest()); break; case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: single_value.field_mBMSSessionUpdateResponse = new MBMSSessionUpdateResponse_template(other_value.mBMSSessionUpdateResponse()); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: single_value.field_mS__InfoChangeNotificationRequest = new MS__InfoChangeNotificationRequest_template(other_value.mS__InfoChangeNotificationRequest()); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: single_value.field_mS__InfoChangeNotificationResponse = new MS__InfoChangeNotificationResponse_template(other_value.mS__InfoChangeNotificationResponse()); break; default: TTCN_error("Initializing a template with an unbound value of type @GTPC_Types.GTPC_PDUs."); } set_selection(SPECIFIC_VALUE); } void GTPC__PDUs_template::copy_template(const GTPC__PDUs_template& other_value) { switch (other_value.template_selection) { case SPECIFIC_VALUE: single_value.union_selection = other_value.single_value.union_selection; switch (single_value.union_selection) { case GTPC__PDUs::ALT_echoRequest: single_value.field_echoRequest = new EchoRequest_template(*other_value.single_value.field_echoRequest); break; case GTPC__PDUs::ALT_echoResponse: single_value.field_echoResponse = new EchoResponse_template(*other_value.single_value.field_echoResponse); break; case GTPC__PDUs::ALT_versionNotSupported: single_value.field_versionNotSupported = new VersionNotSupported_template(*other_value.single_value.field_versionNotSupported); break; case GTPC__PDUs::ALT_createPDPContextRequest: single_value.field_createPDPContextRequest = new CreatePDPContextRequest_template(*other_value.single_value.field_createPDPContextRequest); break; case GTPC__PDUs::ALT_createPDPContextResponse: single_value.field_createPDPContextResponse = new CreatePDPContextResponse_template(*other_value.single_value.field_createPDPContextResponse); break; case GTPC__PDUs::ALT_updatePDPContextRequest: single_value.field_updatePDPContextRequest = new UpdatePDPContextRequest_template(*other_value.single_value.field_updatePDPContextRequest); break; case GTPC__PDUs::ALT_updatePDPContextResponse: single_value.field_updatePDPContextResponse = new UpdatePDPContextResponse_template(*other_value.single_value.field_updatePDPContextResponse); break; case GTPC__PDUs::ALT_deletePDPContextRequest: single_value.field_deletePDPContextRequest = new DeletePDPContextRequest_template(*other_value.single_value.field_deletePDPContextRequest); break; case GTPC__PDUs::ALT_deletePDPContextResponse: single_value.field_deletePDPContextResponse = new DeletePDPContextResponse_template(*other_value.single_value.field_deletePDPContextResponse); break; case GTPC__PDUs::ALT_pdu__NotificationRequest: single_value.field_pdu__NotificationRequest = new PDU__NotificationRequest_template(*other_value.single_value.field_pdu__NotificationRequest); break; case GTPC__PDUs::ALT_pdu__NotificationResponse: single_value.field_pdu__NotificationResponse = new PDU__NotificationResponse_template(*other_value.single_value.field_pdu__NotificationResponse); break; case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: single_value.field_pdu__NotificationRejectRequest = new PDU__NotificationRejectRequest_template(*other_value.single_value.field_pdu__NotificationRejectRequest); break; case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: single_value.field_pdu__NotificationRejectResponse = new PDU__NotificationRejectResponse_template(*other_value.single_value.field_pdu__NotificationRejectResponse); break; case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: single_value.field_initiatePDPContextActivationRequest = new InitiatePDPContextActivationRequest_template(*other_value.single_value.field_initiatePDPContextActivationRequest); break; case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: single_value.field_initiatePDPContextActivationResponse = new InitiatePDPContextActivationResponse_template(*other_value.single_value.field_initiatePDPContextActivationResponse); break; case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: single_value.field_supportedExtensionHeadersNotification = new SupportedExtensionHeadersNotification_template(*other_value.single_value.field_supportedExtensionHeadersNotification); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: single_value.field_sendRouteingInformationForGPRSRequest = new SendRouteingInformationForGPRSRequest_template(*other_value.single_value.field_sendRouteingInformationForGPRSRequest); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: single_value.field_sendRouteingInformationForGPRSResponse = new SendRouteingInformationForGPRSResponse_template(*other_value.single_value.field_sendRouteingInformationForGPRSResponse); break; case GTPC__PDUs::ALT_failureReportRequest: single_value.field_failureReportRequest = new FailureReportRequest_template(*other_value.single_value.field_failureReportRequest); break; case GTPC__PDUs::ALT_failureReportResponse: single_value.field_failureReportResponse = new FailureReportResponse_template(*other_value.single_value.field_failureReportResponse); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: single_value.field_noteMS__GPRSPresentRequest = new NoteMS__GPRSPresentRequest_template(*other_value.single_value.field_noteMS__GPRSPresentRequest); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: single_value.field_noteMS__GPRSPresentResponse = new NoteMS__GPRSPresentResponse_template(*other_value.single_value.field_noteMS__GPRSPresentResponse); break; case GTPC__PDUs::ALT_identificationRequest: single_value.field_identificationRequest = new IdentificationRequest_template(*other_value.single_value.field_identificationRequest); break; case GTPC__PDUs::ALT_identificationResponse: single_value.field_identificationResponse = new IdentificationResponse_template(*other_value.single_value.field_identificationResponse); break; case GTPC__PDUs::ALT_sgsn__ContextRequest: single_value.field_sgsn__ContextRequest = new SGSN__ContextRequest_template(*other_value.single_value.field_sgsn__ContextRequest); break; case GTPC__PDUs::ALT_sgsn__ContextResponse: single_value.field_sgsn__ContextResponse = new SGSN__ContextResponse_template(*other_value.single_value.field_sgsn__ContextResponse); break; case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: single_value.field_sgsn__ContextAcknowledge = new SGSN__ContextAcknowledge_template(*other_value.single_value.field_sgsn__ContextAcknowledge); break; case GTPC__PDUs::ALT_forwardRelocationRequest: single_value.field_forwardRelocationRequest = new ForwardRelocationRequest_template(*other_value.single_value.field_forwardRelocationRequest); break; case GTPC__PDUs::ALT_forwardRelocationResponse: single_value.field_forwardRelocationResponse = new ForwardRelocationResponse_template(*other_value.single_value.field_forwardRelocationResponse); break; case GTPC__PDUs::ALT_forwardRelocationComplete: single_value.field_forwardRelocationComplete = new ForwardRelocationComplete_template(*other_value.single_value.field_forwardRelocationComplete); break; case GTPC__PDUs::ALT_relocationCancelRequest: single_value.field_relocationCancelRequest = new RelocationCancelRequest_template(*other_value.single_value.field_relocationCancelRequest); break; case GTPC__PDUs::ALT_relocationCancelResponse: single_value.field_relocationCancelResponse = new RelocationCancelResponse_template(*other_value.single_value.field_relocationCancelResponse); break; case GTPC__PDUs::ALT_forwardSRNSContext: single_value.field_forwardSRNSContext = new ForwardSRNSContext_template(*other_value.single_value.field_forwardSRNSContext); break; case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: single_value.field_forwardRelocationCompleteAcknowledge = new ForwardRelocationCompleteAcknowledge_template(*other_value.single_value.field_forwardRelocationCompleteAcknowledge); break; case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: single_value.field_forwardSRNSContextAcknowledge = new ForwardSRNSContextAcknowledge_template(*other_value.single_value.field_forwardSRNSContextAcknowledge); break; case GTPC__PDUs::ALT_uERegistrationQueryRequest: single_value.field_uERegistrationQueryRequest = new UERegistrationQueryRequest_template(*other_value.single_value.field_uERegistrationQueryRequest); break; case GTPC__PDUs::ALT_uERegistrationQueryResponse: single_value.field_uERegistrationQueryResponse = new UERegistrationQueryResponse_template(*other_value.single_value.field_uERegistrationQueryResponse); break; case GTPC__PDUs::ALT_ranInformationRelay: single_value.field_ranInformationRelay = new RANInformationRelay_template(*other_value.single_value.field_ranInformationRelay); break; case GTPC__PDUs::ALT_mBMSNotificationRequest: single_value.field_mBMSNotificationRequest = new MBMSNotificationRequest_template(*other_value.single_value.field_mBMSNotificationRequest); break; case GTPC__PDUs::ALT_mBMSNotificationResponse: single_value.field_mBMSNotificationResponse = new MBMSNotificationResponse_template(*other_value.single_value.field_mBMSNotificationResponse); break; case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: single_value.field_mBMSNotificationRejectRequest = new MBMSNotificationRejectRequest_template(*other_value.single_value.field_mBMSNotificationRejectRequest); break; case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: single_value.field_mBMSNotificationRejectResponse = new MBMSNotificationRejectResponse_template(*other_value.single_value.field_mBMSNotificationRejectResponse); break; case GTPC__PDUs::ALT_createMBMSContextRequest: single_value.field_createMBMSContextRequest = new CreateMBMSContextRequest_template(*other_value.single_value.field_createMBMSContextRequest); break; case GTPC__PDUs::ALT_createMBMSContextResponse: single_value.field_createMBMSContextResponse = new CreateMBMSContextResponse_template(*other_value.single_value.field_createMBMSContextResponse); break; case GTPC__PDUs::ALT_updateMBMSContextRequest: single_value.field_updateMBMSContextRequest = new UpdateMBMSContextRequest_template(*other_value.single_value.field_updateMBMSContextRequest); break; case GTPC__PDUs::ALT_updateMBMSContextResponse: single_value.field_updateMBMSContextResponse = new UpdateMBMSContextResponse_template(*other_value.single_value.field_updateMBMSContextResponse); break; case GTPC__PDUs::ALT_deleteMBMSContextRequest: single_value.field_deleteMBMSContextRequest = new DeleteMBMSContextRequest_template(*other_value.single_value.field_deleteMBMSContextRequest); break; case GTPC__PDUs::ALT_deleteMBMSContextResponse: single_value.field_deleteMBMSContextResponse = new DeleteMBMSContextResponse_template(*other_value.single_value.field_deleteMBMSContextResponse); break; case GTPC__PDUs::ALT_mBMSRegistrationRequest: single_value.field_mBMSRegistrationRequest = new MBMSRegistrationRequest__gtpc_template(*other_value.single_value.field_mBMSRegistrationRequest); break; case GTPC__PDUs::ALT_mBMSRegistrationResponse: single_value.field_mBMSRegistrationResponse = new MBMSRegistrationResponse__gtpc_template(*other_value.single_value.field_mBMSRegistrationResponse); break; case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: single_value.field_mBMSDeRegistrationRequest = new MBMSDeRegistrationRequest_template(*other_value.single_value.field_mBMSDeRegistrationRequest); break; case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: single_value.field_mBMSDeRegistrationResponse = new MBMSDeRegistrationResponse_template(*other_value.single_value.field_mBMSDeRegistrationResponse); break; case GTPC__PDUs::ALT_mBMSSessionStartRequest: single_value.field_mBMSSessionStartRequest = new MBMSSessionStartRequest_template(*other_value.single_value.field_mBMSSessionStartRequest); break; case GTPC__PDUs::ALT_mBMSSessionStartResponse: single_value.field_mBMSSessionStartResponse = new MBMSSessionStartResponse__gtpc_template(*other_value.single_value.field_mBMSSessionStartResponse); break; case GTPC__PDUs::ALT_mBMSSessionStopRequest: single_value.field_mBMSSessionStopRequest = new MBMSSessionStopRequest_template(*other_value.single_value.field_mBMSSessionStopRequest); break; case GTPC__PDUs::ALT_mBMSSessionStopResponse: single_value.field_mBMSSessionStopResponse = new MBMSSessionStopResponse__gtpc_template(*other_value.single_value.field_mBMSSessionStopResponse); break; case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: single_value.field_mBMSSessionUpdateRequest = new MBMSSessionUpdateRequest_template(*other_value.single_value.field_mBMSSessionUpdateRequest); break; case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: single_value.field_mBMSSessionUpdateResponse = new MBMSSessionUpdateResponse_template(*other_value.single_value.field_mBMSSessionUpdateResponse); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: single_value.field_mS__InfoChangeNotificationRequest = new MS__InfoChangeNotificationRequest_template(*other_value.single_value.field_mS__InfoChangeNotificationRequest); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: single_value.field_mS__InfoChangeNotificationResponse = new MS__InfoChangeNotificationResponse_template(*other_value.single_value.field_mS__InfoChangeNotificationResponse); break; default: TTCN_error("Internal error: Invalid union selector in a specific value when copying a template of type @GTPC_Types.GTPC_PDUs."); } case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: value_list.n_values = other_value.value_list.n_values; value_list.list_value = new GTPC__PDUs_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]); break; case IMPLICATION_MATCH: implication_.precondition = new GTPC__PDUs_template(*other_value.implication_.precondition); implication_.implied_template = new GTPC__PDUs_template(*other_value.implication_.implied_template); break; case DYNAMIC_MATCH: dyn_match = other_value.dyn_match; dyn_match->ref_count++; break; default: TTCN_error("Copying an uninitialized template of union type @GTPC_Types.GTPC_PDUs."); } set_selection(other_value); } GTPC__PDUs_template::GTPC__PDUs_template() { } GTPC__PDUs_template::GTPC__PDUs_template(template_sel other_value) : Base_Template(other_value) { check_single_selection(other_value); } GTPC__PDUs_template::GTPC__PDUs_template(const GTPC__PDUs& other_value) { copy_value(other_value); } GTPC__PDUs_template::GTPC__PDUs_template(const OPTIONAL& other_value) { switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const GTPC__PDUs&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Creating a template of union type @GTPC_Types.GTPC_PDUs from an unbound optional field."); } } GTPC__PDUs_template::GTPC__PDUs_template(GTPC__PDUs_template* p_precondition, GTPC__PDUs_template* p_implied_template) : Base_Template(IMPLICATION_MATCH) { implication_.precondition = p_precondition; implication_.implied_template = p_implied_template; } GTPC__PDUs_template::GTPC__PDUs_template(Dynamic_Match_Interface* p_dyn_match) : Base_Template(DYNAMIC_MATCH) { dyn_match = new dynmatch_struct; dyn_match->ptr = p_dyn_match; dyn_match->ref_count = 1; } GTPC__PDUs_template::GTPC__PDUs_template(const GTPC__PDUs_template& other_value) : Base_Template(){ copy_template(other_value); } GTPC__PDUs_template::~GTPC__PDUs_template() { clean_up(); } void GTPC__PDUs_template::clean_up() { switch (template_selection) { case SPECIFIC_VALUE: switch (single_value.union_selection) { case GTPC__PDUs::ALT_echoRequest: delete single_value.field_echoRequest; break; case GTPC__PDUs::ALT_echoResponse: delete single_value.field_echoResponse; break; case GTPC__PDUs::ALT_versionNotSupported: delete single_value.field_versionNotSupported; break; case GTPC__PDUs::ALT_createPDPContextRequest: delete single_value.field_createPDPContextRequest; break; case GTPC__PDUs::ALT_createPDPContextResponse: delete single_value.field_createPDPContextResponse; break; case GTPC__PDUs::ALT_updatePDPContextRequest: delete single_value.field_updatePDPContextRequest; break; case GTPC__PDUs::ALT_updatePDPContextResponse: delete single_value.field_updatePDPContextResponse; break; case GTPC__PDUs::ALT_deletePDPContextRequest: delete single_value.field_deletePDPContextRequest; break; case GTPC__PDUs::ALT_deletePDPContextResponse: delete single_value.field_deletePDPContextResponse; break; case GTPC__PDUs::ALT_pdu__NotificationRequest: delete single_value.field_pdu__NotificationRequest; break; case GTPC__PDUs::ALT_pdu__NotificationResponse: delete single_value.field_pdu__NotificationResponse; break; case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: delete single_value.field_pdu__NotificationRejectRequest; break; case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: delete single_value.field_pdu__NotificationRejectResponse; break; case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: delete single_value.field_initiatePDPContextActivationRequest; break; case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: delete single_value.field_initiatePDPContextActivationResponse; break; case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: delete single_value.field_supportedExtensionHeadersNotification; break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: delete single_value.field_sendRouteingInformationForGPRSRequest; break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: delete single_value.field_sendRouteingInformationForGPRSResponse; break; case GTPC__PDUs::ALT_failureReportRequest: delete single_value.field_failureReportRequest; break; case GTPC__PDUs::ALT_failureReportResponse: delete single_value.field_failureReportResponse; break; case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: delete single_value.field_noteMS__GPRSPresentRequest; break; case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: delete single_value.field_noteMS__GPRSPresentResponse; break; case GTPC__PDUs::ALT_identificationRequest: delete single_value.field_identificationRequest; break; case GTPC__PDUs::ALT_identificationResponse: delete single_value.field_identificationResponse; break; case GTPC__PDUs::ALT_sgsn__ContextRequest: delete single_value.field_sgsn__ContextRequest; break; case GTPC__PDUs::ALT_sgsn__ContextResponse: delete single_value.field_sgsn__ContextResponse; break; case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: delete single_value.field_sgsn__ContextAcknowledge; break; case GTPC__PDUs::ALT_forwardRelocationRequest: delete single_value.field_forwardRelocationRequest; break; case GTPC__PDUs::ALT_forwardRelocationResponse: delete single_value.field_forwardRelocationResponse; break; case GTPC__PDUs::ALT_forwardRelocationComplete: delete single_value.field_forwardRelocationComplete; break; case GTPC__PDUs::ALT_relocationCancelRequest: delete single_value.field_relocationCancelRequest; break; case GTPC__PDUs::ALT_relocationCancelResponse: delete single_value.field_relocationCancelResponse; break; case GTPC__PDUs::ALT_forwardSRNSContext: delete single_value.field_forwardSRNSContext; break; case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: delete single_value.field_forwardRelocationCompleteAcknowledge; break; case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: delete single_value.field_forwardSRNSContextAcknowledge; break; case GTPC__PDUs::ALT_uERegistrationQueryRequest: delete single_value.field_uERegistrationQueryRequest; break; case GTPC__PDUs::ALT_uERegistrationQueryResponse: delete single_value.field_uERegistrationQueryResponse; break; case GTPC__PDUs::ALT_ranInformationRelay: delete single_value.field_ranInformationRelay; break; case GTPC__PDUs::ALT_mBMSNotificationRequest: delete single_value.field_mBMSNotificationRequest; break; case GTPC__PDUs::ALT_mBMSNotificationResponse: delete single_value.field_mBMSNotificationResponse; break; case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: delete single_value.field_mBMSNotificationRejectRequest; break; case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: delete single_value.field_mBMSNotificationRejectResponse; break; case GTPC__PDUs::ALT_createMBMSContextRequest: delete single_value.field_createMBMSContextRequest; break; case GTPC__PDUs::ALT_createMBMSContextResponse: delete single_value.field_createMBMSContextResponse; break; case GTPC__PDUs::ALT_updateMBMSContextRequest: delete single_value.field_updateMBMSContextRequest; break; case GTPC__PDUs::ALT_updateMBMSContextResponse: delete single_value.field_updateMBMSContextResponse; break; case GTPC__PDUs::ALT_deleteMBMSContextRequest: delete single_value.field_deleteMBMSContextRequest; break; case GTPC__PDUs::ALT_deleteMBMSContextResponse: delete single_value.field_deleteMBMSContextResponse; break; case GTPC__PDUs::ALT_mBMSRegistrationRequest: delete single_value.field_mBMSRegistrationRequest; break; case GTPC__PDUs::ALT_mBMSRegistrationResponse: delete single_value.field_mBMSRegistrationResponse; break; case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: delete single_value.field_mBMSDeRegistrationRequest; break; case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: delete single_value.field_mBMSDeRegistrationResponse; break; case GTPC__PDUs::ALT_mBMSSessionStartRequest: delete single_value.field_mBMSSessionStartRequest; break; case GTPC__PDUs::ALT_mBMSSessionStartResponse: delete single_value.field_mBMSSessionStartResponse; break; case GTPC__PDUs::ALT_mBMSSessionStopRequest: delete single_value.field_mBMSSessionStopRequest; break; case GTPC__PDUs::ALT_mBMSSessionStopResponse: delete single_value.field_mBMSSessionStopResponse; break; case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: delete single_value.field_mBMSSessionUpdateRequest; break; case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: delete single_value.field_mBMSSessionUpdateResponse; break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: delete single_value.field_mS__InfoChangeNotificationRequest; break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: delete single_value.field_mS__InfoChangeNotificationResponse; default: break; } break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: delete [] value_list.list_value; break; case IMPLICATION_MATCH: delete implication_.precondition; delete implication_.implied_template; break; case DYNAMIC_MATCH: dyn_match->ref_count--; if (dyn_match->ref_count == 0) { delete dyn_match->ptr; delete dyn_match; } break; default: break; } template_selection = UNINITIALIZED_TEMPLATE; } GTPC__PDUs_template& GTPC__PDUs_template::operator=(template_sel other_value) { check_single_selection(other_value); clean_up(); set_selection(other_value); return *this; } GTPC__PDUs_template& GTPC__PDUs_template::operator=(const GTPC__PDUs& other_value) { clean_up(); copy_value(other_value); return *this; } GTPC__PDUs_template& GTPC__PDUs_template::operator=(const OPTIONAL& other_value) { clean_up(); switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const GTPC__PDUs&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Assignment of an unbound optional field to a template of union type @GTPC_Types.GTPC_PDUs."); } return *this; } GTPC__PDUs_template& GTPC__PDUs_template::operator=(const GTPC__PDUs_template& other_value) { if (&other_value != this) { clean_up(); copy_template(other_value); } return *this; } boolean GTPC__PDUs_template::match(const GTPC__PDUs& other_value, boolean legacy) const { if (!other_value.is_bound()) return FALSE; switch (template_selection) { case ANY_VALUE: case ANY_OR_OMIT: return TRUE; case OMIT_VALUE: return FALSE; case SPECIFIC_VALUE: { GTPC__PDUs::union_selection_type value_selection = other_value.get_selection(); if (value_selection == GTPC__PDUs::UNBOUND_VALUE) return FALSE; if (value_selection != single_value.union_selection) return FALSE; switch (value_selection) { case GTPC__PDUs::ALT_echoRequest: return single_value.field_echoRequest->match(other_value.echoRequest(), legacy); case GTPC__PDUs::ALT_echoResponse: return single_value.field_echoResponse->match(other_value.echoResponse(), legacy); case GTPC__PDUs::ALT_versionNotSupported: return single_value.field_versionNotSupported->match(other_value.versionNotSupported(), legacy); case GTPC__PDUs::ALT_createPDPContextRequest: return single_value.field_createPDPContextRequest->match(other_value.createPDPContextRequest(), legacy); case GTPC__PDUs::ALT_createPDPContextResponse: return single_value.field_createPDPContextResponse->match(other_value.createPDPContextResponse(), legacy); case GTPC__PDUs::ALT_updatePDPContextRequest: return single_value.field_updatePDPContextRequest->match(other_value.updatePDPContextRequest(), legacy); case GTPC__PDUs::ALT_updatePDPContextResponse: return single_value.field_updatePDPContextResponse->match(other_value.updatePDPContextResponse(), legacy); case GTPC__PDUs::ALT_deletePDPContextRequest: return single_value.field_deletePDPContextRequest->match(other_value.deletePDPContextRequest(), legacy); case GTPC__PDUs::ALT_deletePDPContextResponse: return single_value.field_deletePDPContextResponse->match(other_value.deletePDPContextResponse(), legacy); case GTPC__PDUs::ALT_pdu__NotificationRequest: return single_value.field_pdu__NotificationRequest->match(other_value.pdu__NotificationRequest(), legacy); case GTPC__PDUs::ALT_pdu__NotificationResponse: return single_value.field_pdu__NotificationResponse->match(other_value.pdu__NotificationResponse(), legacy); case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: return single_value.field_pdu__NotificationRejectRequest->match(other_value.pdu__NotificationRejectRequest(), legacy); case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: return single_value.field_pdu__NotificationRejectResponse->match(other_value.pdu__NotificationRejectResponse(), legacy); case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: return single_value.field_initiatePDPContextActivationRequest->match(other_value.initiatePDPContextActivationRequest(), legacy); case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: return single_value.field_initiatePDPContextActivationResponse->match(other_value.initiatePDPContextActivationResponse(), legacy); case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: return single_value.field_supportedExtensionHeadersNotification->match(other_value.supportedExtensionHeadersNotification(), legacy); case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: return single_value.field_sendRouteingInformationForGPRSRequest->match(other_value.sendRouteingInformationForGPRSRequest(), legacy); case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: return single_value.field_sendRouteingInformationForGPRSResponse->match(other_value.sendRouteingInformationForGPRSResponse(), legacy); case GTPC__PDUs::ALT_failureReportRequest: return single_value.field_failureReportRequest->match(other_value.failureReportRequest(), legacy); case GTPC__PDUs::ALT_failureReportResponse: return single_value.field_failureReportResponse->match(other_value.failureReportResponse(), legacy); case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: return single_value.field_noteMS__GPRSPresentRequest->match(other_value.noteMS__GPRSPresentRequest(), legacy); case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: return single_value.field_noteMS__GPRSPresentResponse->match(other_value.noteMS__GPRSPresentResponse(), legacy); case GTPC__PDUs::ALT_identificationRequest: return single_value.field_identificationRequest->match(other_value.identificationRequest(), legacy); case GTPC__PDUs::ALT_identificationResponse: return single_value.field_identificationResponse->match(other_value.identificationResponse(), legacy); case GTPC__PDUs::ALT_sgsn__ContextRequest: return single_value.field_sgsn__ContextRequest->match(other_value.sgsn__ContextRequest(), legacy); case GTPC__PDUs::ALT_sgsn__ContextResponse: return single_value.field_sgsn__ContextResponse->match(other_value.sgsn__ContextResponse(), legacy); case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: return single_value.field_sgsn__ContextAcknowledge->match(other_value.sgsn__ContextAcknowledge(), legacy); case GTPC__PDUs::ALT_forwardRelocationRequest: return single_value.field_forwardRelocationRequest->match(other_value.forwardRelocationRequest(), legacy); case GTPC__PDUs::ALT_forwardRelocationResponse: return single_value.field_forwardRelocationResponse->match(other_value.forwardRelocationResponse(), legacy); case GTPC__PDUs::ALT_forwardRelocationComplete: return single_value.field_forwardRelocationComplete->match(other_value.forwardRelocationComplete(), legacy); case GTPC__PDUs::ALT_relocationCancelRequest: return single_value.field_relocationCancelRequest->match(other_value.relocationCancelRequest(), legacy); case GTPC__PDUs::ALT_relocationCancelResponse: return single_value.field_relocationCancelResponse->match(other_value.relocationCancelResponse(), legacy); case GTPC__PDUs::ALT_forwardSRNSContext: return single_value.field_forwardSRNSContext->match(other_value.forwardSRNSContext(), legacy); case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: return single_value.field_forwardRelocationCompleteAcknowledge->match(other_value.forwardRelocationCompleteAcknowledge(), legacy); case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: return single_value.field_forwardSRNSContextAcknowledge->match(other_value.forwardSRNSContextAcknowledge(), legacy); case GTPC__PDUs::ALT_uERegistrationQueryRequest: return single_value.field_uERegistrationQueryRequest->match(other_value.uERegistrationQueryRequest(), legacy); case GTPC__PDUs::ALT_uERegistrationQueryResponse: return single_value.field_uERegistrationQueryResponse->match(other_value.uERegistrationQueryResponse(), legacy); case GTPC__PDUs::ALT_ranInformationRelay: return single_value.field_ranInformationRelay->match(other_value.ranInformationRelay(), legacy); case GTPC__PDUs::ALT_mBMSNotificationRequest: return single_value.field_mBMSNotificationRequest->match(other_value.mBMSNotificationRequest(), legacy); case GTPC__PDUs::ALT_mBMSNotificationResponse: return single_value.field_mBMSNotificationResponse->match(other_value.mBMSNotificationResponse(), legacy); case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: return single_value.field_mBMSNotificationRejectRequest->match(other_value.mBMSNotificationRejectRequest(), legacy); case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: return single_value.field_mBMSNotificationRejectResponse->match(other_value.mBMSNotificationRejectResponse(), legacy); case GTPC__PDUs::ALT_createMBMSContextRequest: return single_value.field_createMBMSContextRequest->match(other_value.createMBMSContextRequest(), legacy); case GTPC__PDUs::ALT_createMBMSContextResponse: return single_value.field_createMBMSContextResponse->match(other_value.createMBMSContextResponse(), legacy); case GTPC__PDUs::ALT_updateMBMSContextRequest: return single_value.field_updateMBMSContextRequest->match(other_value.updateMBMSContextRequest(), legacy); case GTPC__PDUs::ALT_updateMBMSContextResponse: return single_value.field_updateMBMSContextResponse->match(other_value.updateMBMSContextResponse(), legacy); case GTPC__PDUs::ALT_deleteMBMSContextRequest: return single_value.field_deleteMBMSContextRequest->match(other_value.deleteMBMSContextRequest(), legacy); case GTPC__PDUs::ALT_deleteMBMSContextResponse: return single_value.field_deleteMBMSContextResponse->match(other_value.deleteMBMSContextResponse(), legacy); case GTPC__PDUs::ALT_mBMSRegistrationRequest: return single_value.field_mBMSRegistrationRequest->match(other_value.mBMSRegistrationRequest(), legacy); case GTPC__PDUs::ALT_mBMSRegistrationResponse: return single_value.field_mBMSRegistrationResponse->match(other_value.mBMSRegistrationResponse(), legacy); case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: return single_value.field_mBMSDeRegistrationRequest->match(other_value.mBMSDeRegistrationRequest(), legacy); case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: return single_value.field_mBMSDeRegistrationResponse->match(other_value.mBMSDeRegistrationResponse(), legacy); case GTPC__PDUs::ALT_mBMSSessionStartRequest: return single_value.field_mBMSSessionStartRequest->match(other_value.mBMSSessionStartRequest(), legacy); case GTPC__PDUs::ALT_mBMSSessionStartResponse: return single_value.field_mBMSSessionStartResponse->match(other_value.mBMSSessionStartResponse(), legacy); case GTPC__PDUs::ALT_mBMSSessionStopRequest: return single_value.field_mBMSSessionStopRequest->match(other_value.mBMSSessionStopRequest(), legacy); case GTPC__PDUs::ALT_mBMSSessionStopResponse: return single_value.field_mBMSSessionStopResponse->match(other_value.mBMSSessionStopResponse(), legacy); case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: return single_value.field_mBMSSessionUpdateRequest->match(other_value.mBMSSessionUpdateRequest(), legacy); case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: return single_value.field_mBMSSessionUpdateResponse->match(other_value.mBMSSessionUpdateResponse(), legacy); case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: return single_value.field_mS__InfoChangeNotificationRequest->match(other_value.mS__InfoChangeNotificationRequest(), legacy); case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: return single_value.field_mS__InfoChangeNotificationResponse->match(other_value.mS__InfoChangeNotificationResponse(), legacy); default: TTCN_error("Internal error: Invalid selector in a specific value when matching a template of union type @GTPC_Types.GTPC_PDUs."); } } case VALUE_LIST: case COMPLEMENTED_LIST: for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) if (value_list.list_value[list_count].match(other_value, legacy)) return template_selection == VALUE_LIST; return template_selection == COMPLEMENTED_LIST; case CONJUNCTION_MATCH: for (unsigned int i = 0; i < value_list.n_values; i++) { if (!value_list.list_value[i].match(other_value)) { return FALSE; } } return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value); case DYNAMIC_MATCH: return dyn_match->ptr->match(other_value); default: TTCN_error ("Matching an uninitialized template of union type @GTPC_Types.GTPC_PDUs."); } return FALSE; } boolean GTPC__PDUs_template::is_value() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE; switch (single_value.union_selection) { case GTPC__PDUs::ALT_echoRequest: return single_value.field_echoRequest->is_value(); case GTPC__PDUs::ALT_echoResponse: return single_value.field_echoResponse->is_value(); case GTPC__PDUs::ALT_versionNotSupported: return single_value.field_versionNotSupported->is_value(); case GTPC__PDUs::ALT_createPDPContextRequest: return single_value.field_createPDPContextRequest->is_value(); case GTPC__PDUs::ALT_createPDPContextResponse: return single_value.field_createPDPContextResponse->is_value(); case GTPC__PDUs::ALT_updatePDPContextRequest: return single_value.field_updatePDPContextRequest->is_value(); case GTPC__PDUs::ALT_updatePDPContextResponse: return single_value.field_updatePDPContextResponse->is_value(); case GTPC__PDUs::ALT_deletePDPContextRequest: return single_value.field_deletePDPContextRequest->is_value(); case GTPC__PDUs::ALT_deletePDPContextResponse: return single_value.field_deletePDPContextResponse->is_value(); case GTPC__PDUs::ALT_pdu__NotificationRequest: return single_value.field_pdu__NotificationRequest->is_value(); case GTPC__PDUs::ALT_pdu__NotificationResponse: return single_value.field_pdu__NotificationResponse->is_value(); case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: return single_value.field_pdu__NotificationRejectRequest->is_value(); case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: return single_value.field_pdu__NotificationRejectResponse->is_value(); case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: return single_value.field_initiatePDPContextActivationRequest->is_value(); case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: return single_value.field_initiatePDPContextActivationResponse->is_value(); case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: return single_value.field_supportedExtensionHeadersNotification->is_value(); case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: return single_value.field_sendRouteingInformationForGPRSRequest->is_value(); case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: return single_value.field_sendRouteingInformationForGPRSResponse->is_value(); case GTPC__PDUs::ALT_failureReportRequest: return single_value.field_failureReportRequest->is_value(); case GTPC__PDUs::ALT_failureReportResponse: return single_value.field_failureReportResponse->is_value(); case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: return single_value.field_noteMS__GPRSPresentRequest->is_value(); case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: return single_value.field_noteMS__GPRSPresentResponse->is_value(); case GTPC__PDUs::ALT_identificationRequest: return single_value.field_identificationRequest->is_value(); case GTPC__PDUs::ALT_identificationResponse: return single_value.field_identificationResponse->is_value(); case GTPC__PDUs::ALT_sgsn__ContextRequest: return single_value.field_sgsn__ContextRequest->is_value(); case GTPC__PDUs::ALT_sgsn__ContextResponse: return single_value.field_sgsn__ContextResponse->is_value(); case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: return single_value.field_sgsn__ContextAcknowledge->is_value(); case GTPC__PDUs::ALT_forwardRelocationRequest: return single_value.field_forwardRelocationRequest->is_value(); case GTPC__PDUs::ALT_forwardRelocationResponse: return single_value.field_forwardRelocationResponse->is_value(); case GTPC__PDUs::ALT_forwardRelocationComplete: return single_value.field_forwardRelocationComplete->is_value(); case GTPC__PDUs::ALT_relocationCancelRequest: return single_value.field_relocationCancelRequest->is_value(); case GTPC__PDUs::ALT_relocationCancelResponse: return single_value.field_relocationCancelResponse->is_value(); case GTPC__PDUs::ALT_forwardSRNSContext: return single_value.field_forwardSRNSContext->is_value(); case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: return single_value.field_forwardRelocationCompleteAcknowledge->is_value(); case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: return single_value.field_forwardSRNSContextAcknowledge->is_value(); case GTPC__PDUs::ALT_uERegistrationQueryRequest: return single_value.field_uERegistrationQueryRequest->is_value(); case GTPC__PDUs::ALT_uERegistrationQueryResponse: return single_value.field_uERegistrationQueryResponse->is_value(); case GTPC__PDUs::ALT_ranInformationRelay: return single_value.field_ranInformationRelay->is_value(); case GTPC__PDUs::ALT_mBMSNotificationRequest: return single_value.field_mBMSNotificationRequest->is_value(); case GTPC__PDUs::ALT_mBMSNotificationResponse: return single_value.field_mBMSNotificationResponse->is_value(); case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: return single_value.field_mBMSNotificationRejectRequest->is_value(); case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: return single_value.field_mBMSNotificationRejectResponse->is_value(); case GTPC__PDUs::ALT_createMBMSContextRequest: return single_value.field_createMBMSContextRequest->is_value(); case GTPC__PDUs::ALT_createMBMSContextResponse: return single_value.field_createMBMSContextResponse->is_value(); case GTPC__PDUs::ALT_updateMBMSContextRequest: return single_value.field_updateMBMSContextRequest->is_value(); case GTPC__PDUs::ALT_updateMBMSContextResponse: return single_value.field_updateMBMSContextResponse->is_value(); case GTPC__PDUs::ALT_deleteMBMSContextRequest: return single_value.field_deleteMBMSContextRequest->is_value(); case GTPC__PDUs::ALT_deleteMBMSContextResponse: return single_value.field_deleteMBMSContextResponse->is_value(); case GTPC__PDUs::ALT_mBMSRegistrationRequest: return single_value.field_mBMSRegistrationRequest->is_value(); case GTPC__PDUs::ALT_mBMSRegistrationResponse: return single_value.field_mBMSRegistrationResponse->is_value(); case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: return single_value.field_mBMSDeRegistrationRequest->is_value(); case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: return single_value.field_mBMSDeRegistrationResponse->is_value(); case GTPC__PDUs::ALT_mBMSSessionStartRequest: return single_value.field_mBMSSessionStartRequest->is_value(); case GTPC__PDUs::ALT_mBMSSessionStartResponse: return single_value.field_mBMSSessionStartResponse->is_value(); case GTPC__PDUs::ALT_mBMSSessionStopRequest: return single_value.field_mBMSSessionStopRequest->is_value(); case GTPC__PDUs::ALT_mBMSSessionStopResponse: return single_value.field_mBMSSessionStopResponse->is_value(); case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: return single_value.field_mBMSSessionUpdateRequest->is_value(); case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: return single_value.field_mBMSSessionUpdateResponse->is_value(); case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: return single_value.field_mS__InfoChangeNotificationRequest->is_value(); case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: return single_value.field_mS__InfoChangeNotificationResponse->is_value(); default: TTCN_error("Internal error: Invalid selector in a specific value when performing is_value operation on a template of union type @GTPC_Types.GTPC_PDUs."); } } GTPC__PDUs GTPC__PDUs_template::valueof() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of union type @GTPC_Types.GTPC_PDUs."); GTPC__PDUs ret_val; switch (single_value.union_selection) { case GTPC__PDUs::ALT_echoRequest: ret_val.echoRequest() = single_value.field_echoRequest->valueof(); break; case GTPC__PDUs::ALT_echoResponse: ret_val.echoResponse() = single_value.field_echoResponse->valueof(); break; case GTPC__PDUs::ALT_versionNotSupported: ret_val.versionNotSupported() = single_value.field_versionNotSupported->valueof(); break; case GTPC__PDUs::ALT_createPDPContextRequest: ret_val.createPDPContextRequest() = single_value.field_createPDPContextRequest->valueof(); break; case GTPC__PDUs::ALT_createPDPContextResponse: ret_val.createPDPContextResponse() = single_value.field_createPDPContextResponse->valueof(); break; case GTPC__PDUs::ALT_updatePDPContextRequest: ret_val.updatePDPContextRequest() = single_value.field_updatePDPContextRequest->valueof(); break; case GTPC__PDUs::ALT_updatePDPContextResponse: ret_val.updatePDPContextResponse() = single_value.field_updatePDPContextResponse->valueof(); break; case GTPC__PDUs::ALT_deletePDPContextRequest: ret_val.deletePDPContextRequest() = single_value.field_deletePDPContextRequest->valueof(); break; case GTPC__PDUs::ALT_deletePDPContextResponse: ret_val.deletePDPContextResponse() = single_value.field_deletePDPContextResponse->valueof(); break; case GTPC__PDUs::ALT_pdu__NotificationRequest: ret_val.pdu__NotificationRequest() = single_value.field_pdu__NotificationRequest->valueof(); break; case GTPC__PDUs::ALT_pdu__NotificationResponse: ret_val.pdu__NotificationResponse() = single_value.field_pdu__NotificationResponse->valueof(); break; case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: ret_val.pdu__NotificationRejectRequest() = single_value.field_pdu__NotificationRejectRequest->valueof(); break; case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: ret_val.pdu__NotificationRejectResponse() = single_value.field_pdu__NotificationRejectResponse->valueof(); break; case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: ret_val.initiatePDPContextActivationRequest() = single_value.field_initiatePDPContextActivationRequest->valueof(); break; case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: ret_val.initiatePDPContextActivationResponse() = single_value.field_initiatePDPContextActivationResponse->valueof(); break; case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: ret_val.supportedExtensionHeadersNotification() = single_value.field_supportedExtensionHeadersNotification->valueof(); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: ret_val.sendRouteingInformationForGPRSRequest() = single_value.field_sendRouteingInformationForGPRSRequest->valueof(); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: ret_val.sendRouteingInformationForGPRSResponse() = single_value.field_sendRouteingInformationForGPRSResponse->valueof(); break; case GTPC__PDUs::ALT_failureReportRequest: ret_val.failureReportRequest() = single_value.field_failureReportRequest->valueof(); break; case GTPC__PDUs::ALT_failureReportResponse: ret_val.failureReportResponse() = single_value.field_failureReportResponse->valueof(); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: ret_val.noteMS__GPRSPresentRequest() = single_value.field_noteMS__GPRSPresentRequest->valueof(); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: ret_val.noteMS__GPRSPresentResponse() = single_value.field_noteMS__GPRSPresentResponse->valueof(); break; case GTPC__PDUs::ALT_identificationRequest: ret_val.identificationRequest() = single_value.field_identificationRequest->valueof(); break; case GTPC__PDUs::ALT_identificationResponse: ret_val.identificationResponse() = single_value.field_identificationResponse->valueof(); break; case GTPC__PDUs::ALT_sgsn__ContextRequest: ret_val.sgsn__ContextRequest() = single_value.field_sgsn__ContextRequest->valueof(); break; case GTPC__PDUs::ALT_sgsn__ContextResponse: ret_val.sgsn__ContextResponse() = single_value.field_sgsn__ContextResponse->valueof(); break; case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: ret_val.sgsn__ContextAcknowledge() = single_value.field_sgsn__ContextAcknowledge->valueof(); break; case GTPC__PDUs::ALT_forwardRelocationRequest: ret_val.forwardRelocationRequest() = single_value.field_forwardRelocationRequest->valueof(); break; case GTPC__PDUs::ALT_forwardRelocationResponse: ret_val.forwardRelocationResponse() = single_value.field_forwardRelocationResponse->valueof(); break; case GTPC__PDUs::ALT_forwardRelocationComplete: ret_val.forwardRelocationComplete() = single_value.field_forwardRelocationComplete->valueof(); break; case GTPC__PDUs::ALT_relocationCancelRequest: ret_val.relocationCancelRequest() = single_value.field_relocationCancelRequest->valueof(); break; case GTPC__PDUs::ALT_relocationCancelResponse: ret_val.relocationCancelResponse() = single_value.field_relocationCancelResponse->valueof(); break; case GTPC__PDUs::ALT_forwardSRNSContext: ret_val.forwardSRNSContext() = single_value.field_forwardSRNSContext->valueof(); break; case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: ret_val.forwardRelocationCompleteAcknowledge() = single_value.field_forwardRelocationCompleteAcknowledge->valueof(); break; case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: ret_val.forwardSRNSContextAcknowledge() = single_value.field_forwardSRNSContextAcknowledge->valueof(); break; case GTPC__PDUs::ALT_uERegistrationQueryRequest: ret_val.uERegistrationQueryRequest() = single_value.field_uERegistrationQueryRequest->valueof(); break; case GTPC__PDUs::ALT_uERegistrationQueryResponse: ret_val.uERegistrationQueryResponse() = single_value.field_uERegistrationQueryResponse->valueof(); break; case GTPC__PDUs::ALT_ranInformationRelay: ret_val.ranInformationRelay() = single_value.field_ranInformationRelay->valueof(); break; case GTPC__PDUs::ALT_mBMSNotificationRequest: ret_val.mBMSNotificationRequest() = single_value.field_mBMSNotificationRequest->valueof(); break; case GTPC__PDUs::ALT_mBMSNotificationResponse: ret_val.mBMSNotificationResponse() = single_value.field_mBMSNotificationResponse->valueof(); break; case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: ret_val.mBMSNotificationRejectRequest() = single_value.field_mBMSNotificationRejectRequest->valueof(); break; case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: ret_val.mBMSNotificationRejectResponse() = single_value.field_mBMSNotificationRejectResponse->valueof(); break; case GTPC__PDUs::ALT_createMBMSContextRequest: ret_val.createMBMSContextRequest() = single_value.field_createMBMSContextRequest->valueof(); break; case GTPC__PDUs::ALT_createMBMSContextResponse: ret_val.createMBMSContextResponse() = single_value.field_createMBMSContextResponse->valueof(); break; case GTPC__PDUs::ALT_updateMBMSContextRequest: ret_val.updateMBMSContextRequest() = single_value.field_updateMBMSContextRequest->valueof(); break; case GTPC__PDUs::ALT_updateMBMSContextResponse: ret_val.updateMBMSContextResponse() = single_value.field_updateMBMSContextResponse->valueof(); break; case GTPC__PDUs::ALT_deleteMBMSContextRequest: ret_val.deleteMBMSContextRequest() = single_value.field_deleteMBMSContextRequest->valueof(); break; case GTPC__PDUs::ALT_deleteMBMSContextResponse: ret_val.deleteMBMSContextResponse() = single_value.field_deleteMBMSContextResponse->valueof(); break; case GTPC__PDUs::ALT_mBMSRegistrationRequest: ret_val.mBMSRegistrationRequest() = single_value.field_mBMSRegistrationRequest->valueof(); break; case GTPC__PDUs::ALT_mBMSRegistrationResponse: ret_val.mBMSRegistrationResponse() = single_value.field_mBMSRegistrationResponse->valueof(); break; case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: ret_val.mBMSDeRegistrationRequest() = single_value.field_mBMSDeRegistrationRequest->valueof(); break; case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: ret_val.mBMSDeRegistrationResponse() = single_value.field_mBMSDeRegistrationResponse->valueof(); break; case GTPC__PDUs::ALT_mBMSSessionStartRequest: ret_val.mBMSSessionStartRequest() = single_value.field_mBMSSessionStartRequest->valueof(); break; case GTPC__PDUs::ALT_mBMSSessionStartResponse: ret_val.mBMSSessionStartResponse() = single_value.field_mBMSSessionStartResponse->valueof(); break; case GTPC__PDUs::ALT_mBMSSessionStopRequest: ret_val.mBMSSessionStopRequest() = single_value.field_mBMSSessionStopRequest->valueof(); break; case GTPC__PDUs::ALT_mBMSSessionStopResponse: ret_val.mBMSSessionStopResponse() = single_value.field_mBMSSessionStopResponse->valueof(); break; case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: ret_val.mBMSSessionUpdateRequest() = single_value.field_mBMSSessionUpdateRequest->valueof(); break; case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: ret_val.mBMSSessionUpdateResponse() = single_value.field_mBMSSessionUpdateResponse->valueof(); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: ret_val.mS__InfoChangeNotificationRequest() = single_value.field_mS__InfoChangeNotificationRequest->valueof(); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: ret_val.mS__InfoChangeNotificationResponse() = single_value.field_mS__InfoChangeNotificationResponse->valueof(); break; default: TTCN_error("Internal error: Invalid selector in a specific value when performing valueof operation on a template of union type @GTPC_Types.GTPC_PDUs."); } return ret_val; } GTPC__PDUs_template& GTPC__PDUs_template::list_item(unsigned int list_index) const { if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST && template_selection != CONJUNCTION_MATCH) TTCN_error("Internal error: Accessing a list element of a non-list template of union type @GTPC_Types.GTPC_PDUs."); if (list_index >= value_list.n_values) TTCN_error("Internal error: Index overflow in a value list template of union type @GTPC_Types.GTPC_PDUs."); return value_list.list_value[list_index]; } void GTPC__PDUs_template::set_type(template_sel template_type, unsigned int list_length) { if (template_type != VALUE_LIST && template_type != COMPLEMENTED_LIST && template_type != CONJUNCTION_MATCH) TTCN_error ("Internal error: Setting an invalid list for a template of union type @GTPC_Types.GTPC_PDUs."); clean_up(); set_selection(template_type); value_list.n_values = list_length; value_list.list_value = new GTPC__PDUs_template[list_length]; } EchoRequest_template& GTPC__PDUs_template::echoRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_echoRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_echoRequest = new EchoRequest_template(ANY_VALUE); else single_value.field_echoRequest = new EchoRequest_template; single_value.union_selection = GTPC__PDUs::ALT_echoRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_echoRequest; } const EchoRequest_template& GTPC__PDUs_template::echoRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field echoRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_echoRequest) TTCN_error("Accessing non-selected field echoRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_echoRequest; } EchoResponse_template& GTPC__PDUs_template::echoResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_echoResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_echoResponse = new EchoResponse_template(ANY_VALUE); else single_value.field_echoResponse = new EchoResponse_template; single_value.union_selection = GTPC__PDUs::ALT_echoResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_echoResponse; } const EchoResponse_template& GTPC__PDUs_template::echoResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field echoResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_echoResponse) TTCN_error("Accessing non-selected field echoResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_echoResponse; } VersionNotSupported_template& GTPC__PDUs_template::versionNotSupported() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_versionNotSupported) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_versionNotSupported = new VersionNotSupported_template(ANY_VALUE); else single_value.field_versionNotSupported = new VersionNotSupported_template; single_value.union_selection = GTPC__PDUs::ALT_versionNotSupported; set_selection(SPECIFIC_VALUE); } return *single_value.field_versionNotSupported; } const VersionNotSupported_template& GTPC__PDUs_template::versionNotSupported() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field versionNotSupported in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_versionNotSupported) TTCN_error("Accessing non-selected field versionNotSupported in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_versionNotSupported; } CreatePDPContextRequest_template& GTPC__PDUs_template::createPDPContextRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_createPDPContextRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_createPDPContextRequest = new CreatePDPContextRequest_template(ANY_VALUE); else single_value.field_createPDPContextRequest = new CreatePDPContextRequest_template; single_value.union_selection = GTPC__PDUs::ALT_createPDPContextRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_createPDPContextRequest; } const CreatePDPContextRequest_template& GTPC__PDUs_template::createPDPContextRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field createPDPContextRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_createPDPContextRequest) TTCN_error("Accessing non-selected field createPDPContextRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_createPDPContextRequest; } CreatePDPContextResponse_template& GTPC__PDUs_template::createPDPContextResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_createPDPContextResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_createPDPContextResponse = new CreatePDPContextResponse_template(ANY_VALUE); else single_value.field_createPDPContextResponse = new CreatePDPContextResponse_template; single_value.union_selection = GTPC__PDUs::ALT_createPDPContextResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_createPDPContextResponse; } const CreatePDPContextResponse_template& GTPC__PDUs_template::createPDPContextResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field createPDPContextResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_createPDPContextResponse) TTCN_error("Accessing non-selected field createPDPContextResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_createPDPContextResponse; } UpdatePDPContextRequest_template& GTPC__PDUs_template::updatePDPContextRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_updatePDPContextRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_updatePDPContextRequest = new UpdatePDPContextRequest_template(ANY_VALUE); else single_value.field_updatePDPContextRequest = new UpdatePDPContextRequest_template; single_value.union_selection = GTPC__PDUs::ALT_updatePDPContextRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_updatePDPContextRequest; } const UpdatePDPContextRequest_template& GTPC__PDUs_template::updatePDPContextRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field updatePDPContextRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_updatePDPContextRequest) TTCN_error("Accessing non-selected field updatePDPContextRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_updatePDPContextRequest; } UpdatePDPContextResponse_template& GTPC__PDUs_template::updatePDPContextResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_updatePDPContextResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_updatePDPContextResponse = new UpdatePDPContextResponse_template(ANY_VALUE); else single_value.field_updatePDPContextResponse = new UpdatePDPContextResponse_template; single_value.union_selection = GTPC__PDUs::ALT_updatePDPContextResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_updatePDPContextResponse; } const UpdatePDPContextResponse_template& GTPC__PDUs_template::updatePDPContextResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field updatePDPContextResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_updatePDPContextResponse) TTCN_error("Accessing non-selected field updatePDPContextResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_updatePDPContextResponse; } DeletePDPContextRequest_template& GTPC__PDUs_template::deletePDPContextRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_deletePDPContextRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_deletePDPContextRequest = new DeletePDPContextRequest_template(ANY_VALUE); else single_value.field_deletePDPContextRequest = new DeletePDPContextRequest_template; single_value.union_selection = GTPC__PDUs::ALT_deletePDPContextRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_deletePDPContextRequest; } const DeletePDPContextRequest_template& GTPC__PDUs_template::deletePDPContextRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field deletePDPContextRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_deletePDPContextRequest) TTCN_error("Accessing non-selected field deletePDPContextRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_deletePDPContextRequest; } DeletePDPContextResponse_template& GTPC__PDUs_template::deletePDPContextResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_deletePDPContextResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_deletePDPContextResponse = new DeletePDPContextResponse_template(ANY_VALUE); else single_value.field_deletePDPContextResponse = new DeletePDPContextResponse_template; single_value.union_selection = GTPC__PDUs::ALT_deletePDPContextResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_deletePDPContextResponse; } const DeletePDPContextResponse_template& GTPC__PDUs_template::deletePDPContextResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field deletePDPContextResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_deletePDPContextResponse) TTCN_error("Accessing non-selected field deletePDPContextResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_deletePDPContextResponse; } PDU__NotificationRequest_template& GTPC__PDUs_template::pdu__NotificationRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_pdu__NotificationRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_pdu__NotificationRequest = new PDU__NotificationRequest_template(ANY_VALUE); else single_value.field_pdu__NotificationRequest = new PDU__NotificationRequest_template; single_value.union_selection = GTPC__PDUs::ALT_pdu__NotificationRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_pdu__NotificationRequest; } const PDU__NotificationRequest_template& GTPC__PDUs_template::pdu__NotificationRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field pdu_NotificationRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_pdu__NotificationRequest) TTCN_error("Accessing non-selected field pdu_NotificationRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_pdu__NotificationRequest; } PDU__NotificationResponse_template& GTPC__PDUs_template::pdu__NotificationResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_pdu__NotificationResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_pdu__NotificationResponse = new PDU__NotificationResponse_template(ANY_VALUE); else single_value.field_pdu__NotificationResponse = new PDU__NotificationResponse_template; single_value.union_selection = GTPC__PDUs::ALT_pdu__NotificationResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_pdu__NotificationResponse; } const PDU__NotificationResponse_template& GTPC__PDUs_template::pdu__NotificationResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field pdu_NotificationResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_pdu__NotificationResponse) TTCN_error("Accessing non-selected field pdu_NotificationResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_pdu__NotificationResponse; } PDU__NotificationRejectRequest_template& GTPC__PDUs_template::pdu__NotificationRejectRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_pdu__NotificationRejectRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_pdu__NotificationRejectRequest = new PDU__NotificationRejectRequest_template(ANY_VALUE); else single_value.field_pdu__NotificationRejectRequest = new PDU__NotificationRejectRequest_template; single_value.union_selection = GTPC__PDUs::ALT_pdu__NotificationRejectRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_pdu__NotificationRejectRequest; } const PDU__NotificationRejectRequest_template& GTPC__PDUs_template::pdu__NotificationRejectRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field pdu_NotificationRejectRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_pdu__NotificationRejectRequest) TTCN_error("Accessing non-selected field pdu_NotificationRejectRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_pdu__NotificationRejectRequest; } PDU__NotificationRejectResponse_template& GTPC__PDUs_template::pdu__NotificationRejectResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_pdu__NotificationRejectResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_pdu__NotificationRejectResponse = new PDU__NotificationRejectResponse_template(ANY_VALUE); else single_value.field_pdu__NotificationRejectResponse = new PDU__NotificationRejectResponse_template; single_value.union_selection = GTPC__PDUs::ALT_pdu__NotificationRejectResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_pdu__NotificationRejectResponse; } const PDU__NotificationRejectResponse_template& GTPC__PDUs_template::pdu__NotificationRejectResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field pdu_NotificationRejectResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_pdu__NotificationRejectResponse) TTCN_error("Accessing non-selected field pdu_NotificationRejectResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_pdu__NotificationRejectResponse; } InitiatePDPContextActivationRequest_template& GTPC__PDUs_template::initiatePDPContextActivationRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_initiatePDPContextActivationRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_initiatePDPContextActivationRequest = new InitiatePDPContextActivationRequest_template(ANY_VALUE); else single_value.field_initiatePDPContextActivationRequest = new InitiatePDPContextActivationRequest_template; single_value.union_selection = GTPC__PDUs::ALT_initiatePDPContextActivationRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_initiatePDPContextActivationRequest; } const InitiatePDPContextActivationRequest_template& GTPC__PDUs_template::initiatePDPContextActivationRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field initiatePDPContextActivationRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_initiatePDPContextActivationRequest) TTCN_error("Accessing non-selected field initiatePDPContextActivationRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_initiatePDPContextActivationRequest; } InitiatePDPContextActivationResponse_template& GTPC__PDUs_template::initiatePDPContextActivationResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_initiatePDPContextActivationResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_initiatePDPContextActivationResponse = new InitiatePDPContextActivationResponse_template(ANY_VALUE); else single_value.field_initiatePDPContextActivationResponse = new InitiatePDPContextActivationResponse_template; single_value.union_selection = GTPC__PDUs::ALT_initiatePDPContextActivationResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_initiatePDPContextActivationResponse; } const InitiatePDPContextActivationResponse_template& GTPC__PDUs_template::initiatePDPContextActivationResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field initiatePDPContextActivationResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_initiatePDPContextActivationResponse) TTCN_error("Accessing non-selected field initiatePDPContextActivationResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_initiatePDPContextActivationResponse; } SupportedExtensionHeadersNotification_template& GTPC__PDUs_template::supportedExtensionHeadersNotification() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_supportedExtensionHeadersNotification) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_supportedExtensionHeadersNotification = new SupportedExtensionHeadersNotification_template(ANY_VALUE); else single_value.field_supportedExtensionHeadersNotification = new SupportedExtensionHeadersNotification_template; single_value.union_selection = GTPC__PDUs::ALT_supportedExtensionHeadersNotification; set_selection(SPECIFIC_VALUE); } return *single_value.field_supportedExtensionHeadersNotification; } const SupportedExtensionHeadersNotification_template& GTPC__PDUs_template::supportedExtensionHeadersNotification() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field supportedExtensionHeadersNotification in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_supportedExtensionHeadersNotification) TTCN_error("Accessing non-selected field supportedExtensionHeadersNotification in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_supportedExtensionHeadersNotification; } SendRouteingInformationForGPRSRequest_template& GTPC__PDUs_template::sendRouteingInformationForGPRSRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_sendRouteingInformationForGPRSRequest = new SendRouteingInformationForGPRSRequest_template(ANY_VALUE); else single_value.field_sendRouteingInformationForGPRSRequest = new SendRouteingInformationForGPRSRequest_template; single_value.union_selection = GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_sendRouteingInformationForGPRSRequest; } const SendRouteingInformationForGPRSRequest_template& GTPC__PDUs_template::sendRouteingInformationForGPRSRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field sendRouteingInformationForGPRSRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest) TTCN_error("Accessing non-selected field sendRouteingInformationForGPRSRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_sendRouteingInformationForGPRSRequest; } SendRouteingInformationForGPRSResponse_template& GTPC__PDUs_template::sendRouteingInformationForGPRSResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_sendRouteingInformationForGPRSResponse = new SendRouteingInformationForGPRSResponse_template(ANY_VALUE); else single_value.field_sendRouteingInformationForGPRSResponse = new SendRouteingInformationForGPRSResponse_template; single_value.union_selection = GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_sendRouteingInformationForGPRSResponse; } const SendRouteingInformationForGPRSResponse_template& GTPC__PDUs_template::sendRouteingInformationForGPRSResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field sendRouteingInformationForGPRSResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse) TTCN_error("Accessing non-selected field sendRouteingInformationForGPRSResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_sendRouteingInformationForGPRSResponse; } FailureReportRequest_template& GTPC__PDUs_template::failureReportRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_failureReportRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_failureReportRequest = new FailureReportRequest_template(ANY_VALUE); else single_value.field_failureReportRequest = new FailureReportRequest_template; single_value.union_selection = GTPC__PDUs::ALT_failureReportRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_failureReportRequest; } const FailureReportRequest_template& GTPC__PDUs_template::failureReportRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field failureReportRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_failureReportRequest) TTCN_error("Accessing non-selected field failureReportRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_failureReportRequest; } FailureReportResponse_template& GTPC__PDUs_template::failureReportResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_failureReportResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_failureReportResponse = new FailureReportResponse_template(ANY_VALUE); else single_value.field_failureReportResponse = new FailureReportResponse_template; single_value.union_selection = GTPC__PDUs::ALT_failureReportResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_failureReportResponse; } const FailureReportResponse_template& GTPC__PDUs_template::failureReportResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field failureReportResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_failureReportResponse) TTCN_error("Accessing non-selected field failureReportResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_failureReportResponse; } NoteMS__GPRSPresentRequest_template& GTPC__PDUs_template::noteMS__GPRSPresentRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_noteMS__GPRSPresentRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_noteMS__GPRSPresentRequest = new NoteMS__GPRSPresentRequest_template(ANY_VALUE); else single_value.field_noteMS__GPRSPresentRequest = new NoteMS__GPRSPresentRequest_template; single_value.union_selection = GTPC__PDUs::ALT_noteMS__GPRSPresentRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_noteMS__GPRSPresentRequest; } const NoteMS__GPRSPresentRequest_template& GTPC__PDUs_template::noteMS__GPRSPresentRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field noteMS_GPRSPresentRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_noteMS__GPRSPresentRequest) TTCN_error("Accessing non-selected field noteMS_GPRSPresentRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_noteMS__GPRSPresentRequest; } NoteMS__GPRSPresentResponse_template& GTPC__PDUs_template::noteMS__GPRSPresentResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_noteMS__GPRSPresentResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_noteMS__GPRSPresentResponse = new NoteMS__GPRSPresentResponse_template(ANY_VALUE); else single_value.field_noteMS__GPRSPresentResponse = new NoteMS__GPRSPresentResponse_template; single_value.union_selection = GTPC__PDUs::ALT_noteMS__GPRSPresentResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_noteMS__GPRSPresentResponse; } const NoteMS__GPRSPresentResponse_template& GTPC__PDUs_template::noteMS__GPRSPresentResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field noteMS_GPRSPresentResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_noteMS__GPRSPresentResponse) TTCN_error("Accessing non-selected field noteMS_GPRSPresentResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_noteMS__GPRSPresentResponse; } IdentificationRequest_template& GTPC__PDUs_template::identificationRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_identificationRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_identificationRequest = new IdentificationRequest_template(ANY_VALUE); else single_value.field_identificationRequest = new IdentificationRequest_template; single_value.union_selection = GTPC__PDUs::ALT_identificationRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_identificationRequest; } const IdentificationRequest_template& GTPC__PDUs_template::identificationRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field identificationRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_identificationRequest) TTCN_error("Accessing non-selected field identificationRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_identificationRequest; } IdentificationResponse_template& GTPC__PDUs_template::identificationResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_identificationResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_identificationResponse = new IdentificationResponse_template(ANY_VALUE); else single_value.field_identificationResponse = new IdentificationResponse_template; single_value.union_selection = GTPC__PDUs::ALT_identificationResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_identificationResponse; } const IdentificationResponse_template& GTPC__PDUs_template::identificationResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field identificationResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_identificationResponse) TTCN_error("Accessing non-selected field identificationResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_identificationResponse; } SGSN__ContextRequest_template& GTPC__PDUs_template::sgsn__ContextRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_sgsn__ContextRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_sgsn__ContextRequest = new SGSN__ContextRequest_template(ANY_VALUE); else single_value.field_sgsn__ContextRequest = new SGSN__ContextRequest_template; single_value.union_selection = GTPC__PDUs::ALT_sgsn__ContextRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_sgsn__ContextRequest; } const SGSN__ContextRequest_template& GTPC__PDUs_template::sgsn__ContextRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field sgsn_ContextRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_sgsn__ContextRequest) TTCN_error("Accessing non-selected field sgsn_ContextRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_sgsn__ContextRequest; } SGSN__ContextResponse_template& GTPC__PDUs_template::sgsn__ContextResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_sgsn__ContextResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_sgsn__ContextResponse = new SGSN__ContextResponse_template(ANY_VALUE); else single_value.field_sgsn__ContextResponse = new SGSN__ContextResponse_template; single_value.union_selection = GTPC__PDUs::ALT_sgsn__ContextResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_sgsn__ContextResponse; } const SGSN__ContextResponse_template& GTPC__PDUs_template::sgsn__ContextResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field sgsn_ContextResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_sgsn__ContextResponse) TTCN_error("Accessing non-selected field sgsn_ContextResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_sgsn__ContextResponse; } SGSN__ContextAcknowledge_template& GTPC__PDUs_template::sgsn__ContextAcknowledge() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_sgsn__ContextAcknowledge) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_sgsn__ContextAcknowledge = new SGSN__ContextAcknowledge_template(ANY_VALUE); else single_value.field_sgsn__ContextAcknowledge = new SGSN__ContextAcknowledge_template; single_value.union_selection = GTPC__PDUs::ALT_sgsn__ContextAcknowledge; set_selection(SPECIFIC_VALUE); } return *single_value.field_sgsn__ContextAcknowledge; } const SGSN__ContextAcknowledge_template& GTPC__PDUs_template::sgsn__ContextAcknowledge() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field sgsn_ContextAcknowledge in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_sgsn__ContextAcknowledge) TTCN_error("Accessing non-selected field sgsn_ContextAcknowledge in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_sgsn__ContextAcknowledge; } ForwardRelocationRequest_template& GTPC__PDUs_template::forwardRelocationRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_forwardRelocationRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_forwardRelocationRequest = new ForwardRelocationRequest_template(ANY_VALUE); else single_value.field_forwardRelocationRequest = new ForwardRelocationRequest_template; single_value.union_selection = GTPC__PDUs::ALT_forwardRelocationRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_forwardRelocationRequest; } const ForwardRelocationRequest_template& GTPC__PDUs_template::forwardRelocationRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field forwardRelocationRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_forwardRelocationRequest) TTCN_error("Accessing non-selected field forwardRelocationRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_forwardRelocationRequest; } ForwardRelocationResponse_template& GTPC__PDUs_template::forwardRelocationResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_forwardRelocationResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_forwardRelocationResponse = new ForwardRelocationResponse_template(ANY_VALUE); else single_value.field_forwardRelocationResponse = new ForwardRelocationResponse_template; single_value.union_selection = GTPC__PDUs::ALT_forwardRelocationResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_forwardRelocationResponse; } const ForwardRelocationResponse_template& GTPC__PDUs_template::forwardRelocationResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field forwardRelocationResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_forwardRelocationResponse) TTCN_error("Accessing non-selected field forwardRelocationResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_forwardRelocationResponse; } ForwardRelocationComplete_template& GTPC__PDUs_template::forwardRelocationComplete() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_forwardRelocationComplete) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_forwardRelocationComplete = new ForwardRelocationComplete_template(ANY_VALUE); else single_value.field_forwardRelocationComplete = new ForwardRelocationComplete_template; single_value.union_selection = GTPC__PDUs::ALT_forwardRelocationComplete; set_selection(SPECIFIC_VALUE); } return *single_value.field_forwardRelocationComplete; } const ForwardRelocationComplete_template& GTPC__PDUs_template::forwardRelocationComplete() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field forwardRelocationComplete in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_forwardRelocationComplete) TTCN_error("Accessing non-selected field forwardRelocationComplete in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_forwardRelocationComplete; } RelocationCancelRequest_template& GTPC__PDUs_template::relocationCancelRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_relocationCancelRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_relocationCancelRequest = new RelocationCancelRequest_template(ANY_VALUE); else single_value.field_relocationCancelRequest = new RelocationCancelRequest_template; single_value.union_selection = GTPC__PDUs::ALT_relocationCancelRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_relocationCancelRequest; } const RelocationCancelRequest_template& GTPC__PDUs_template::relocationCancelRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field relocationCancelRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_relocationCancelRequest) TTCN_error("Accessing non-selected field relocationCancelRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_relocationCancelRequest; } RelocationCancelResponse_template& GTPC__PDUs_template::relocationCancelResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_relocationCancelResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_relocationCancelResponse = new RelocationCancelResponse_template(ANY_VALUE); else single_value.field_relocationCancelResponse = new RelocationCancelResponse_template; single_value.union_selection = GTPC__PDUs::ALT_relocationCancelResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_relocationCancelResponse; } const RelocationCancelResponse_template& GTPC__PDUs_template::relocationCancelResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field relocationCancelResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_relocationCancelResponse) TTCN_error("Accessing non-selected field relocationCancelResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_relocationCancelResponse; } ForwardSRNSContext_template& GTPC__PDUs_template::forwardSRNSContext() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_forwardSRNSContext) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_forwardSRNSContext = new ForwardSRNSContext_template(ANY_VALUE); else single_value.field_forwardSRNSContext = new ForwardSRNSContext_template; single_value.union_selection = GTPC__PDUs::ALT_forwardSRNSContext; set_selection(SPECIFIC_VALUE); } return *single_value.field_forwardSRNSContext; } const ForwardSRNSContext_template& GTPC__PDUs_template::forwardSRNSContext() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field forwardSRNSContext in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_forwardSRNSContext) TTCN_error("Accessing non-selected field forwardSRNSContext in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_forwardSRNSContext; } ForwardRelocationCompleteAcknowledge_template& GTPC__PDUs_template::forwardRelocationCompleteAcknowledge() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_forwardRelocationCompleteAcknowledge = new ForwardRelocationCompleteAcknowledge_template(ANY_VALUE); else single_value.field_forwardRelocationCompleteAcknowledge = new ForwardRelocationCompleteAcknowledge_template; single_value.union_selection = GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge; set_selection(SPECIFIC_VALUE); } return *single_value.field_forwardRelocationCompleteAcknowledge; } const ForwardRelocationCompleteAcknowledge_template& GTPC__PDUs_template::forwardRelocationCompleteAcknowledge() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field forwardRelocationCompleteAcknowledge in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge) TTCN_error("Accessing non-selected field forwardRelocationCompleteAcknowledge in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_forwardRelocationCompleteAcknowledge; } ForwardSRNSContextAcknowledge_template& GTPC__PDUs_template::forwardSRNSContextAcknowledge() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_forwardSRNSContextAcknowledge) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_forwardSRNSContextAcknowledge = new ForwardSRNSContextAcknowledge_template(ANY_VALUE); else single_value.field_forwardSRNSContextAcknowledge = new ForwardSRNSContextAcknowledge_template; single_value.union_selection = GTPC__PDUs::ALT_forwardSRNSContextAcknowledge; set_selection(SPECIFIC_VALUE); } return *single_value.field_forwardSRNSContextAcknowledge; } const ForwardSRNSContextAcknowledge_template& GTPC__PDUs_template::forwardSRNSContextAcknowledge() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field forwardSRNSContextAcknowledge in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_forwardSRNSContextAcknowledge) TTCN_error("Accessing non-selected field forwardSRNSContextAcknowledge in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_forwardSRNSContextAcknowledge; } UERegistrationQueryRequest_template& GTPC__PDUs_template::uERegistrationQueryRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_uERegistrationQueryRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_uERegistrationQueryRequest = new UERegistrationQueryRequest_template(ANY_VALUE); else single_value.field_uERegistrationQueryRequest = new UERegistrationQueryRequest_template; single_value.union_selection = GTPC__PDUs::ALT_uERegistrationQueryRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_uERegistrationQueryRequest; } const UERegistrationQueryRequest_template& GTPC__PDUs_template::uERegistrationQueryRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field uERegistrationQueryRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_uERegistrationQueryRequest) TTCN_error("Accessing non-selected field uERegistrationQueryRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_uERegistrationQueryRequest; } UERegistrationQueryResponse_template& GTPC__PDUs_template::uERegistrationQueryResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_uERegistrationQueryResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_uERegistrationQueryResponse = new UERegistrationQueryResponse_template(ANY_VALUE); else single_value.field_uERegistrationQueryResponse = new UERegistrationQueryResponse_template; single_value.union_selection = GTPC__PDUs::ALT_uERegistrationQueryResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_uERegistrationQueryResponse; } const UERegistrationQueryResponse_template& GTPC__PDUs_template::uERegistrationQueryResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field uERegistrationQueryResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_uERegistrationQueryResponse) TTCN_error("Accessing non-selected field uERegistrationQueryResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_uERegistrationQueryResponse; } RANInformationRelay_template& GTPC__PDUs_template::ranInformationRelay() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_ranInformationRelay) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_ranInformationRelay = new RANInformationRelay_template(ANY_VALUE); else single_value.field_ranInformationRelay = new RANInformationRelay_template; single_value.union_selection = GTPC__PDUs::ALT_ranInformationRelay; set_selection(SPECIFIC_VALUE); } return *single_value.field_ranInformationRelay; } const RANInformationRelay_template& GTPC__PDUs_template::ranInformationRelay() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field ranInformationRelay in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_ranInformationRelay) TTCN_error("Accessing non-selected field ranInformationRelay in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_ranInformationRelay; } MBMSNotificationRequest_template& GTPC__PDUs_template::mBMSNotificationRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSNotificationRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSNotificationRequest = new MBMSNotificationRequest_template(ANY_VALUE); else single_value.field_mBMSNotificationRequest = new MBMSNotificationRequest_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSNotificationRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSNotificationRequest; } const MBMSNotificationRequest_template& GTPC__PDUs_template::mBMSNotificationRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSNotificationRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSNotificationRequest) TTCN_error("Accessing non-selected field mBMSNotificationRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSNotificationRequest; } MBMSNotificationResponse_template& GTPC__PDUs_template::mBMSNotificationResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSNotificationResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSNotificationResponse = new MBMSNotificationResponse_template(ANY_VALUE); else single_value.field_mBMSNotificationResponse = new MBMSNotificationResponse_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSNotificationResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSNotificationResponse; } const MBMSNotificationResponse_template& GTPC__PDUs_template::mBMSNotificationResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSNotificationResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSNotificationResponse) TTCN_error("Accessing non-selected field mBMSNotificationResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSNotificationResponse; } MBMSNotificationRejectRequest_template& GTPC__PDUs_template::mBMSNotificationRejectRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSNotificationRejectRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSNotificationRejectRequest = new MBMSNotificationRejectRequest_template(ANY_VALUE); else single_value.field_mBMSNotificationRejectRequest = new MBMSNotificationRejectRequest_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSNotificationRejectRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSNotificationRejectRequest; } const MBMSNotificationRejectRequest_template& GTPC__PDUs_template::mBMSNotificationRejectRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSNotificationRejectRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSNotificationRejectRequest) TTCN_error("Accessing non-selected field mBMSNotificationRejectRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSNotificationRejectRequest; } MBMSNotificationRejectResponse_template& GTPC__PDUs_template::mBMSNotificationRejectResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSNotificationRejectResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSNotificationRejectResponse = new MBMSNotificationRejectResponse_template(ANY_VALUE); else single_value.field_mBMSNotificationRejectResponse = new MBMSNotificationRejectResponse_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSNotificationRejectResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSNotificationRejectResponse; } const MBMSNotificationRejectResponse_template& GTPC__PDUs_template::mBMSNotificationRejectResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSNotificationRejectResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSNotificationRejectResponse) TTCN_error("Accessing non-selected field mBMSNotificationRejectResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSNotificationRejectResponse; } CreateMBMSContextRequest_template& GTPC__PDUs_template::createMBMSContextRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_createMBMSContextRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_createMBMSContextRequest = new CreateMBMSContextRequest_template(ANY_VALUE); else single_value.field_createMBMSContextRequest = new CreateMBMSContextRequest_template; single_value.union_selection = GTPC__PDUs::ALT_createMBMSContextRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_createMBMSContextRequest; } const CreateMBMSContextRequest_template& GTPC__PDUs_template::createMBMSContextRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field createMBMSContextRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_createMBMSContextRequest) TTCN_error("Accessing non-selected field createMBMSContextRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_createMBMSContextRequest; } CreateMBMSContextResponse_template& GTPC__PDUs_template::createMBMSContextResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_createMBMSContextResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_createMBMSContextResponse = new CreateMBMSContextResponse_template(ANY_VALUE); else single_value.field_createMBMSContextResponse = new CreateMBMSContextResponse_template; single_value.union_selection = GTPC__PDUs::ALT_createMBMSContextResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_createMBMSContextResponse; } const CreateMBMSContextResponse_template& GTPC__PDUs_template::createMBMSContextResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field createMBMSContextResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_createMBMSContextResponse) TTCN_error("Accessing non-selected field createMBMSContextResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_createMBMSContextResponse; } UpdateMBMSContextRequest_template& GTPC__PDUs_template::updateMBMSContextRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_updateMBMSContextRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_updateMBMSContextRequest = new UpdateMBMSContextRequest_template(ANY_VALUE); else single_value.field_updateMBMSContextRequest = new UpdateMBMSContextRequest_template; single_value.union_selection = GTPC__PDUs::ALT_updateMBMSContextRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_updateMBMSContextRequest; } const UpdateMBMSContextRequest_template& GTPC__PDUs_template::updateMBMSContextRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field updateMBMSContextRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_updateMBMSContextRequest) TTCN_error("Accessing non-selected field updateMBMSContextRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_updateMBMSContextRequest; } UpdateMBMSContextResponse_template& GTPC__PDUs_template::updateMBMSContextResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_updateMBMSContextResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_updateMBMSContextResponse = new UpdateMBMSContextResponse_template(ANY_VALUE); else single_value.field_updateMBMSContextResponse = new UpdateMBMSContextResponse_template; single_value.union_selection = GTPC__PDUs::ALT_updateMBMSContextResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_updateMBMSContextResponse; } const UpdateMBMSContextResponse_template& GTPC__PDUs_template::updateMBMSContextResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field updateMBMSContextResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_updateMBMSContextResponse) TTCN_error("Accessing non-selected field updateMBMSContextResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_updateMBMSContextResponse; } DeleteMBMSContextRequest_template& GTPC__PDUs_template::deleteMBMSContextRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_deleteMBMSContextRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_deleteMBMSContextRequest = new DeleteMBMSContextRequest_template(ANY_VALUE); else single_value.field_deleteMBMSContextRequest = new DeleteMBMSContextRequest_template; single_value.union_selection = GTPC__PDUs::ALT_deleteMBMSContextRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_deleteMBMSContextRequest; } const DeleteMBMSContextRequest_template& GTPC__PDUs_template::deleteMBMSContextRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field deleteMBMSContextRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_deleteMBMSContextRequest) TTCN_error("Accessing non-selected field deleteMBMSContextRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_deleteMBMSContextRequest; } DeleteMBMSContextResponse_template& GTPC__PDUs_template::deleteMBMSContextResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_deleteMBMSContextResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_deleteMBMSContextResponse = new DeleteMBMSContextResponse_template(ANY_VALUE); else single_value.field_deleteMBMSContextResponse = new DeleteMBMSContextResponse_template; single_value.union_selection = GTPC__PDUs::ALT_deleteMBMSContextResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_deleteMBMSContextResponse; } const DeleteMBMSContextResponse_template& GTPC__PDUs_template::deleteMBMSContextResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field deleteMBMSContextResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_deleteMBMSContextResponse) TTCN_error("Accessing non-selected field deleteMBMSContextResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_deleteMBMSContextResponse; } MBMSRegistrationRequest__gtpc_template& GTPC__PDUs_template::mBMSRegistrationRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSRegistrationRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSRegistrationRequest = new MBMSRegistrationRequest__gtpc_template(ANY_VALUE); else single_value.field_mBMSRegistrationRequest = new MBMSRegistrationRequest__gtpc_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSRegistrationRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSRegistrationRequest; } const MBMSRegistrationRequest__gtpc_template& GTPC__PDUs_template::mBMSRegistrationRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSRegistrationRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSRegistrationRequest) TTCN_error("Accessing non-selected field mBMSRegistrationRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSRegistrationRequest; } MBMSRegistrationResponse__gtpc_template& GTPC__PDUs_template::mBMSRegistrationResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSRegistrationResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSRegistrationResponse = new MBMSRegistrationResponse__gtpc_template(ANY_VALUE); else single_value.field_mBMSRegistrationResponse = new MBMSRegistrationResponse__gtpc_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSRegistrationResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSRegistrationResponse; } const MBMSRegistrationResponse__gtpc_template& GTPC__PDUs_template::mBMSRegistrationResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSRegistrationResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSRegistrationResponse) TTCN_error("Accessing non-selected field mBMSRegistrationResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSRegistrationResponse; } MBMSDeRegistrationRequest_template& GTPC__PDUs_template::mBMSDeRegistrationRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSDeRegistrationRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSDeRegistrationRequest = new MBMSDeRegistrationRequest_template(ANY_VALUE); else single_value.field_mBMSDeRegistrationRequest = new MBMSDeRegistrationRequest_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSDeRegistrationRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSDeRegistrationRequest; } const MBMSDeRegistrationRequest_template& GTPC__PDUs_template::mBMSDeRegistrationRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSDeRegistrationRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSDeRegistrationRequest) TTCN_error("Accessing non-selected field mBMSDeRegistrationRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSDeRegistrationRequest; } MBMSDeRegistrationResponse_template& GTPC__PDUs_template::mBMSDeRegistrationResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSDeRegistrationResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSDeRegistrationResponse = new MBMSDeRegistrationResponse_template(ANY_VALUE); else single_value.field_mBMSDeRegistrationResponse = new MBMSDeRegistrationResponse_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSDeRegistrationResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSDeRegistrationResponse; } const MBMSDeRegistrationResponse_template& GTPC__PDUs_template::mBMSDeRegistrationResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSDeRegistrationResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSDeRegistrationResponse) TTCN_error("Accessing non-selected field mBMSDeRegistrationResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSDeRegistrationResponse; } MBMSSessionStartRequest_template& GTPC__PDUs_template::mBMSSessionStartRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionStartRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSSessionStartRequest = new MBMSSessionStartRequest_template(ANY_VALUE); else single_value.field_mBMSSessionStartRequest = new MBMSSessionStartRequest_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSSessionStartRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSSessionStartRequest; } const MBMSSessionStartRequest_template& GTPC__PDUs_template::mBMSSessionStartRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSSessionStartRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionStartRequest) TTCN_error("Accessing non-selected field mBMSSessionStartRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSSessionStartRequest; } MBMSSessionStartResponse__gtpc_template& GTPC__PDUs_template::mBMSSessionStartResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionStartResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSSessionStartResponse = new MBMSSessionStartResponse__gtpc_template(ANY_VALUE); else single_value.field_mBMSSessionStartResponse = new MBMSSessionStartResponse__gtpc_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSSessionStartResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSSessionStartResponse; } const MBMSSessionStartResponse__gtpc_template& GTPC__PDUs_template::mBMSSessionStartResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSSessionStartResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionStartResponse) TTCN_error("Accessing non-selected field mBMSSessionStartResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSSessionStartResponse; } MBMSSessionStopRequest_template& GTPC__PDUs_template::mBMSSessionStopRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionStopRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSSessionStopRequest = new MBMSSessionStopRequest_template(ANY_VALUE); else single_value.field_mBMSSessionStopRequest = new MBMSSessionStopRequest_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSSessionStopRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSSessionStopRequest; } const MBMSSessionStopRequest_template& GTPC__PDUs_template::mBMSSessionStopRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSSessionStopRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionStopRequest) TTCN_error("Accessing non-selected field mBMSSessionStopRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSSessionStopRequest; } MBMSSessionStopResponse__gtpc_template& GTPC__PDUs_template::mBMSSessionStopResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionStopResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSSessionStopResponse = new MBMSSessionStopResponse__gtpc_template(ANY_VALUE); else single_value.field_mBMSSessionStopResponse = new MBMSSessionStopResponse__gtpc_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSSessionStopResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSSessionStopResponse; } const MBMSSessionStopResponse__gtpc_template& GTPC__PDUs_template::mBMSSessionStopResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSSessionStopResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionStopResponse) TTCN_error("Accessing non-selected field mBMSSessionStopResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSSessionStopResponse; } MBMSSessionUpdateRequest_template& GTPC__PDUs_template::mBMSSessionUpdateRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionUpdateRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSSessionUpdateRequest = new MBMSSessionUpdateRequest_template(ANY_VALUE); else single_value.field_mBMSSessionUpdateRequest = new MBMSSessionUpdateRequest_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSSessionUpdateRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSSessionUpdateRequest; } const MBMSSessionUpdateRequest_template& GTPC__PDUs_template::mBMSSessionUpdateRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSSessionUpdateRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionUpdateRequest) TTCN_error("Accessing non-selected field mBMSSessionUpdateRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSSessionUpdateRequest; } MBMSSessionUpdateResponse_template& GTPC__PDUs_template::mBMSSessionUpdateResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionUpdateResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mBMSSessionUpdateResponse = new MBMSSessionUpdateResponse_template(ANY_VALUE); else single_value.field_mBMSSessionUpdateResponse = new MBMSSessionUpdateResponse_template; single_value.union_selection = GTPC__PDUs::ALT_mBMSSessionUpdateResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_mBMSSessionUpdateResponse; } const MBMSSessionUpdateResponse_template& GTPC__PDUs_template::mBMSSessionUpdateResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mBMSSessionUpdateResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mBMSSessionUpdateResponse) TTCN_error("Accessing non-selected field mBMSSessionUpdateResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mBMSSessionUpdateResponse; } MS__InfoChangeNotificationRequest_template& GTPC__PDUs_template::mS__InfoChangeNotificationRequest() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mS__InfoChangeNotificationRequest = new MS__InfoChangeNotificationRequest_template(ANY_VALUE); else single_value.field_mS__InfoChangeNotificationRequest = new MS__InfoChangeNotificationRequest_template; single_value.union_selection = GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest; set_selection(SPECIFIC_VALUE); } return *single_value.field_mS__InfoChangeNotificationRequest; } const MS__InfoChangeNotificationRequest_template& GTPC__PDUs_template::mS__InfoChangeNotificationRequest() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mS_InfoChangeNotificationRequest in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest) TTCN_error("Accessing non-selected field mS_InfoChangeNotificationRequest in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mS__InfoChangeNotificationRequest; } MS__InfoChangeNotificationResponse_template& GTPC__PDUs_template::mS__InfoChangeNotificationResponse() { if (template_selection != SPECIFIC_VALUE || single_value.union_selection != GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse) { template_sel old_selection = template_selection; clean_up(); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) single_value.field_mS__InfoChangeNotificationResponse = new MS__InfoChangeNotificationResponse_template(ANY_VALUE); else single_value.field_mS__InfoChangeNotificationResponse = new MS__InfoChangeNotificationResponse_template; single_value.union_selection = GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse; set_selection(SPECIFIC_VALUE); } return *single_value.field_mS__InfoChangeNotificationResponse; } const MS__InfoChangeNotificationResponse_template& GTPC__PDUs_template::mS__InfoChangeNotificationResponse() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field mS_InfoChangeNotificationResponse in a non-specific template of union type @GTPC_Types.GTPC_PDUs."); if (single_value.union_selection != GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse) TTCN_error("Accessing non-selected field mS_InfoChangeNotificationResponse in a template of union type @GTPC_Types.GTPC_PDUs."); return *single_value.field_mS__InfoChangeNotificationResponse; } boolean GTPC__PDUs_template::ischosen(GTPC__PDUs::union_selection_type checked_selection) const { if (checked_selection == GTPC__PDUs::UNBOUND_VALUE) TTCN_error("Internal error: Performing ischosen() operation on an invalid field of union type @GTPC_Types.GTPC_PDUs."); switch (template_selection) { case SPECIFIC_VALUE: if (single_value.union_selection == GTPC__PDUs::UNBOUND_VALUE) TTCN_error("Internal error: Invalid selector in a specific value when performing ischosen() operation on a template of union type @GTPC_Types.GTPC_PDUs."); return single_value.union_selection == checked_selection; case VALUE_LIST: { if (value_list.n_values < 1) TTCN_error("Internal error: Performing ischosen() operation on a template of union type @GTPC_Types.GTPC_PDUs containing an empty list."); boolean ret_val = value_list.list_value[0].ischosen(checked_selection); for (unsigned int list_count = 1; ret_val == TRUE && list_count < value_list.n_values; list_count++) { ret_val = value_list.list_value[list_count].ischosen(checked_selection); } return ret_val; } default: return FALSE; } return FALSE; } void GTPC__PDUs_template::log() const { switch (template_selection) { case SPECIFIC_VALUE: switch (single_value.union_selection) { case GTPC__PDUs::ALT_echoRequest: TTCN_Logger::log_event_str("{ echoRequest := "); single_value.field_echoRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_echoResponse: TTCN_Logger::log_event_str("{ echoResponse := "); single_value.field_echoResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_versionNotSupported: TTCN_Logger::log_event_str("{ versionNotSupported := "); single_value.field_versionNotSupported->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_createPDPContextRequest: TTCN_Logger::log_event_str("{ createPDPContextRequest := "); single_value.field_createPDPContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_createPDPContextResponse: TTCN_Logger::log_event_str("{ createPDPContextResponse := "); single_value.field_createPDPContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_updatePDPContextRequest: TTCN_Logger::log_event_str("{ updatePDPContextRequest := "); single_value.field_updatePDPContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_updatePDPContextResponse: TTCN_Logger::log_event_str("{ updatePDPContextResponse := "); single_value.field_updatePDPContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_deletePDPContextRequest: TTCN_Logger::log_event_str("{ deletePDPContextRequest := "); single_value.field_deletePDPContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_deletePDPContextResponse: TTCN_Logger::log_event_str("{ deletePDPContextResponse := "); single_value.field_deletePDPContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_pdu__NotificationRequest: TTCN_Logger::log_event_str("{ pdu_NotificationRequest := "); single_value.field_pdu__NotificationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_pdu__NotificationResponse: TTCN_Logger::log_event_str("{ pdu_NotificationResponse := "); single_value.field_pdu__NotificationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: TTCN_Logger::log_event_str("{ pdu_NotificationRejectRequest := "); single_value.field_pdu__NotificationRejectRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: TTCN_Logger::log_event_str("{ pdu_NotificationRejectResponse := "); single_value.field_pdu__NotificationRejectResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: TTCN_Logger::log_event_str("{ initiatePDPContextActivationRequest := "); single_value.field_initiatePDPContextActivationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: TTCN_Logger::log_event_str("{ initiatePDPContextActivationResponse := "); single_value.field_initiatePDPContextActivationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: TTCN_Logger::log_event_str("{ supportedExtensionHeadersNotification := "); single_value.field_supportedExtensionHeadersNotification->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: TTCN_Logger::log_event_str("{ sendRouteingInformationForGPRSRequest := "); single_value.field_sendRouteingInformationForGPRSRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: TTCN_Logger::log_event_str("{ sendRouteingInformationForGPRSResponse := "); single_value.field_sendRouteingInformationForGPRSResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_failureReportRequest: TTCN_Logger::log_event_str("{ failureReportRequest := "); single_value.field_failureReportRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_failureReportResponse: TTCN_Logger::log_event_str("{ failureReportResponse := "); single_value.field_failureReportResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: TTCN_Logger::log_event_str("{ noteMS_GPRSPresentRequest := "); single_value.field_noteMS__GPRSPresentRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: TTCN_Logger::log_event_str("{ noteMS_GPRSPresentResponse := "); single_value.field_noteMS__GPRSPresentResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_identificationRequest: TTCN_Logger::log_event_str("{ identificationRequest := "); single_value.field_identificationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_identificationResponse: TTCN_Logger::log_event_str("{ identificationResponse := "); single_value.field_identificationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_sgsn__ContextRequest: TTCN_Logger::log_event_str("{ sgsn_ContextRequest := "); single_value.field_sgsn__ContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_sgsn__ContextResponse: TTCN_Logger::log_event_str("{ sgsn_ContextResponse := "); single_value.field_sgsn__ContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: TTCN_Logger::log_event_str("{ sgsn_ContextAcknowledge := "); single_value.field_sgsn__ContextAcknowledge->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_forwardRelocationRequest: TTCN_Logger::log_event_str("{ forwardRelocationRequest := "); single_value.field_forwardRelocationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_forwardRelocationResponse: TTCN_Logger::log_event_str("{ forwardRelocationResponse := "); single_value.field_forwardRelocationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_forwardRelocationComplete: TTCN_Logger::log_event_str("{ forwardRelocationComplete := "); single_value.field_forwardRelocationComplete->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_relocationCancelRequest: TTCN_Logger::log_event_str("{ relocationCancelRequest := "); single_value.field_relocationCancelRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_relocationCancelResponse: TTCN_Logger::log_event_str("{ relocationCancelResponse := "); single_value.field_relocationCancelResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_forwardSRNSContext: TTCN_Logger::log_event_str("{ forwardSRNSContext := "); single_value.field_forwardSRNSContext->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: TTCN_Logger::log_event_str("{ forwardRelocationCompleteAcknowledge := "); single_value.field_forwardRelocationCompleteAcknowledge->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: TTCN_Logger::log_event_str("{ forwardSRNSContextAcknowledge := "); single_value.field_forwardSRNSContextAcknowledge->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_uERegistrationQueryRequest: TTCN_Logger::log_event_str("{ uERegistrationQueryRequest := "); single_value.field_uERegistrationQueryRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_uERegistrationQueryResponse: TTCN_Logger::log_event_str("{ uERegistrationQueryResponse := "); single_value.field_uERegistrationQueryResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_ranInformationRelay: TTCN_Logger::log_event_str("{ ranInformationRelay := "); single_value.field_ranInformationRelay->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSNotificationRequest: TTCN_Logger::log_event_str("{ mBMSNotificationRequest := "); single_value.field_mBMSNotificationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSNotificationResponse: TTCN_Logger::log_event_str("{ mBMSNotificationResponse := "); single_value.field_mBMSNotificationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: TTCN_Logger::log_event_str("{ mBMSNotificationRejectRequest := "); single_value.field_mBMSNotificationRejectRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: TTCN_Logger::log_event_str("{ mBMSNotificationRejectResponse := "); single_value.field_mBMSNotificationRejectResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_createMBMSContextRequest: TTCN_Logger::log_event_str("{ createMBMSContextRequest := "); single_value.field_createMBMSContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_createMBMSContextResponse: TTCN_Logger::log_event_str("{ createMBMSContextResponse := "); single_value.field_createMBMSContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_updateMBMSContextRequest: TTCN_Logger::log_event_str("{ updateMBMSContextRequest := "); single_value.field_updateMBMSContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_updateMBMSContextResponse: TTCN_Logger::log_event_str("{ updateMBMSContextResponse := "); single_value.field_updateMBMSContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_deleteMBMSContextRequest: TTCN_Logger::log_event_str("{ deleteMBMSContextRequest := "); single_value.field_deleteMBMSContextRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_deleteMBMSContextResponse: TTCN_Logger::log_event_str("{ deleteMBMSContextResponse := "); single_value.field_deleteMBMSContextResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSRegistrationRequest: TTCN_Logger::log_event_str("{ mBMSRegistrationRequest := "); single_value.field_mBMSRegistrationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSRegistrationResponse: TTCN_Logger::log_event_str("{ mBMSRegistrationResponse := "); single_value.field_mBMSRegistrationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: TTCN_Logger::log_event_str("{ mBMSDeRegistrationRequest := "); single_value.field_mBMSDeRegistrationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: TTCN_Logger::log_event_str("{ mBMSDeRegistrationResponse := "); single_value.field_mBMSDeRegistrationResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSSessionStartRequest: TTCN_Logger::log_event_str("{ mBMSSessionStartRequest := "); single_value.field_mBMSSessionStartRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSSessionStartResponse: TTCN_Logger::log_event_str("{ mBMSSessionStartResponse := "); single_value.field_mBMSSessionStartResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSSessionStopRequest: TTCN_Logger::log_event_str("{ mBMSSessionStopRequest := "); single_value.field_mBMSSessionStopRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSSessionStopResponse: TTCN_Logger::log_event_str("{ mBMSSessionStopResponse := "); single_value.field_mBMSSessionStopResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: TTCN_Logger::log_event_str("{ mBMSSessionUpdateRequest := "); single_value.field_mBMSSessionUpdateRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: TTCN_Logger::log_event_str("{ mBMSSessionUpdateResponse := "); single_value.field_mBMSSessionUpdateResponse->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: TTCN_Logger::log_event_str("{ mS_InfoChangeNotificationRequest := "); single_value.field_mS__InfoChangeNotificationRequest->log(); TTCN_Logger::log_event_str(" }"); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: TTCN_Logger::log_event_str("{ mS_InfoChangeNotificationResponse := "); single_value.field_mS__InfoChangeNotificationResponse->log(); TTCN_Logger::log_event_str(" }"); break; default: TTCN_Logger::log_event_str(""); } break; case COMPLEMENTED_LIST: TTCN_Logger::log_event_str("complement"); case CONJUNCTION_MATCH: if (template_selection == CONJUNCTION_MATCH) { TTCN_Logger::log_event_str("conjunct"); } case VALUE_LIST: TTCN_Logger::log_char('('); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) { if (list_count > 0) TTCN_Logger::log_event_str(", "); value_list.list_value[list_count].log(); } TTCN_Logger::log_char(')'); break; case IMPLICATION_MATCH: implication_.precondition->log(); TTCN_Logger::log_event_str(" implies "); implication_.implied_template->log(); break; case DYNAMIC_MATCH: TTCN_Logger::log_event_str("@dynamic template"); break; default: log_generic(); } log_ifpresent(); } void GTPC__PDUs_template::log_match(const GTPC__PDUs& match_value, boolean legacy) const { if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity() && match(match_value, legacy)){ TTCN_Logger::print_logmatch_buffer(); TTCN_Logger::log_event_str(" matched"); return; } if (template_selection == SPECIFIC_VALUE && single_value.union_selection == match_value.get_selection()) { size_t previous_size = TTCN_Logger::get_logmatch_buffer_len(); switch (single_value.union_selection) { case GTPC__PDUs::ALT_echoRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".echoRequest"); single_value.field_echoRequest->log_match(match_value.echoRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ echoRequest := "); single_value.field_echoRequest->log_match(match_value.echoRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_echoResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".echoResponse"); single_value.field_echoResponse->log_match(match_value.echoResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ echoResponse := "); single_value.field_echoResponse->log_match(match_value.echoResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_versionNotSupported: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".versionNotSupported"); single_value.field_versionNotSupported->log_match(match_value.versionNotSupported(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ versionNotSupported := "); single_value.field_versionNotSupported->log_match(match_value.versionNotSupported(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_createPDPContextRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".createPDPContextRequest"); single_value.field_createPDPContextRequest->log_match(match_value.createPDPContextRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ createPDPContextRequest := "); single_value.field_createPDPContextRequest->log_match(match_value.createPDPContextRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_createPDPContextResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".createPDPContextResponse"); single_value.field_createPDPContextResponse->log_match(match_value.createPDPContextResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ createPDPContextResponse := "); single_value.field_createPDPContextResponse->log_match(match_value.createPDPContextResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_updatePDPContextRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".updatePDPContextRequest"); single_value.field_updatePDPContextRequest->log_match(match_value.updatePDPContextRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ updatePDPContextRequest := "); single_value.field_updatePDPContextRequest->log_match(match_value.updatePDPContextRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_updatePDPContextResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".updatePDPContextResponse"); single_value.field_updatePDPContextResponse->log_match(match_value.updatePDPContextResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ updatePDPContextResponse := "); single_value.field_updatePDPContextResponse->log_match(match_value.updatePDPContextResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_deletePDPContextRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".deletePDPContextRequest"); single_value.field_deletePDPContextRequest->log_match(match_value.deletePDPContextRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ deletePDPContextRequest := "); single_value.field_deletePDPContextRequest->log_match(match_value.deletePDPContextRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_deletePDPContextResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".deletePDPContextResponse"); single_value.field_deletePDPContextResponse->log_match(match_value.deletePDPContextResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ deletePDPContextResponse := "); single_value.field_deletePDPContextResponse->log_match(match_value.deletePDPContextResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_pdu__NotificationRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".pdu_NotificationRequest"); single_value.field_pdu__NotificationRequest->log_match(match_value.pdu__NotificationRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ pdu_NotificationRequest := "); single_value.field_pdu__NotificationRequest->log_match(match_value.pdu__NotificationRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_pdu__NotificationResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".pdu_NotificationResponse"); single_value.field_pdu__NotificationResponse->log_match(match_value.pdu__NotificationResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ pdu_NotificationResponse := "); single_value.field_pdu__NotificationResponse->log_match(match_value.pdu__NotificationResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".pdu_NotificationRejectRequest"); single_value.field_pdu__NotificationRejectRequest->log_match(match_value.pdu__NotificationRejectRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ pdu_NotificationRejectRequest := "); single_value.field_pdu__NotificationRejectRequest->log_match(match_value.pdu__NotificationRejectRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".pdu_NotificationRejectResponse"); single_value.field_pdu__NotificationRejectResponse->log_match(match_value.pdu__NotificationRejectResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ pdu_NotificationRejectResponse := "); single_value.field_pdu__NotificationRejectResponse->log_match(match_value.pdu__NotificationRejectResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".initiatePDPContextActivationRequest"); single_value.field_initiatePDPContextActivationRequest->log_match(match_value.initiatePDPContextActivationRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ initiatePDPContextActivationRequest := "); single_value.field_initiatePDPContextActivationRequest->log_match(match_value.initiatePDPContextActivationRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".initiatePDPContextActivationResponse"); single_value.field_initiatePDPContextActivationResponse->log_match(match_value.initiatePDPContextActivationResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ initiatePDPContextActivationResponse := "); single_value.field_initiatePDPContextActivationResponse->log_match(match_value.initiatePDPContextActivationResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".supportedExtensionHeadersNotification"); single_value.field_supportedExtensionHeadersNotification->log_match(match_value.supportedExtensionHeadersNotification(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ supportedExtensionHeadersNotification := "); single_value.field_supportedExtensionHeadersNotification->log_match(match_value.supportedExtensionHeadersNotification(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".sendRouteingInformationForGPRSRequest"); single_value.field_sendRouteingInformationForGPRSRequest->log_match(match_value.sendRouteingInformationForGPRSRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ sendRouteingInformationForGPRSRequest := "); single_value.field_sendRouteingInformationForGPRSRequest->log_match(match_value.sendRouteingInformationForGPRSRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".sendRouteingInformationForGPRSResponse"); single_value.field_sendRouteingInformationForGPRSResponse->log_match(match_value.sendRouteingInformationForGPRSResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ sendRouteingInformationForGPRSResponse := "); single_value.field_sendRouteingInformationForGPRSResponse->log_match(match_value.sendRouteingInformationForGPRSResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_failureReportRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".failureReportRequest"); single_value.field_failureReportRequest->log_match(match_value.failureReportRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ failureReportRequest := "); single_value.field_failureReportRequest->log_match(match_value.failureReportRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_failureReportResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".failureReportResponse"); single_value.field_failureReportResponse->log_match(match_value.failureReportResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ failureReportResponse := "); single_value.field_failureReportResponse->log_match(match_value.failureReportResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".noteMS_GPRSPresentRequest"); single_value.field_noteMS__GPRSPresentRequest->log_match(match_value.noteMS__GPRSPresentRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ noteMS_GPRSPresentRequest := "); single_value.field_noteMS__GPRSPresentRequest->log_match(match_value.noteMS__GPRSPresentRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".noteMS_GPRSPresentResponse"); single_value.field_noteMS__GPRSPresentResponse->log_match(match_value.noteMS__GPRSPresentResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ noteMS_GPRSPresentResponse := "); single_value.field_noteMS__GPRSPresentResponse->log_match(match_value.noteMS__GPRSPresentResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_identificationRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".identificationRequest"); single_value.field_identificationRequest->log_match(match_value.identificationRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ identificationRequest := "); single_value.field_identificationRequest->log_match(match_value.identificationRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_identificationResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".identificationResponse"); single_value.field_identificationResponse->log_match(match_value.identificationResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ identificationResponse := "); single_value.field_identificationResponse->log_match(match_value.identificationResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_sgsn__ContextRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".sgsn_ContextRequest"); single_value.field_sgsn__ContextRequest->log_match(match_value.sgsn__ContextRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ sgsn_ContextRequest := "); single_value.field_sgsn__ContextRequest->log_match(match_value.sgsn__ContextRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_sgsn__ContextResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".sgsn_ContextResponse"); single_value.field_sgsn__ContextResponse->log_match(match_value.sgsn__ContextResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ sgsn_ContextResponse := "); single_value.field_sgsn__ContextResponse->log_match(match_value.sgsn__ContextResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".sgsn_ContextAcknowledge"); single_value.field_sgsn__ContextAcknowledge->log_match(match_value.sgsn__ContextAcknowledge(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ sgsn_ContextAcknowledge := "); single_value.field_sgsn__ContextAcknowledge->log_match(match_value.sgsn__ContextAcknowledge(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_forwardRelocationRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".forwardRelocationRequest"); single_value.field_forwardRelocationRequest->log_match(match_value.forwardRelocationRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ forwardRelocationRequest := "); single_value.field_forwardRelocationRequest->log_match(match_value.forwardRelocationRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_forwardRelocationResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".forwardRelocationResponse"); single_value.field_forwardRelocationResponse->log_match(match_value.forwardRelocationResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ forwardRelocationResponse := "); single_value.field_forwardRelocationResponse->log_match(match_value.forwardRelocationResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_forwardRelocationComplete: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".forwardRelocationComplete"); single_value.field_forwardRelocationComplete->log_match(match_value.forwardRelocationComplete(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ forwardRelocationComplete := "); single_value.field_forwardRelocationComplete->log_match(match_value.forwardRelocationComplete(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_relocationCancelRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".relocationCancelRequest"); single_value.field_relocationCancelRequest->log_match(match_value.relocationCancelRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ relocationCancelRequest := "); single_value.field_relocationCancelRequest->log_match(match_value.relocationCancelRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_relocationCancelResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".relocationCancelResponse"); single_value.field_relocationCancelResponse->log_match(match_value.relocationCancelResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ relocationCancelResponse := "); single_value.field_relocationCancelResponse->log_match(match_value.relocationCancelResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_forwardSRNSContext: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".forwardSRNSContext"); single_value.field_forwardSRNSContext->log_match(match_value.forwardSRNSContext(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ forwardSRNSContext := "); single_value.field_forwardSRNSContext->log_match(match_value.forwardSRNSContext(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".forwardRelocationCompleteAcknowledge"); single_value.field_forwardRelocationCompleteAcknowledge->log_match(match_value.forwardRelocationCompleteAcknowledge(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ forwardRelocationCompleteAcknowledge := "); single_value.field_forwardRelocationCompleteAcknowledge->log_match(match_value.forwardRelocationCompleteAcknowledge(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".forwardSRNSContextAcknowledge"); single_value.field_forwardSRNSContextAcknowledge->log_match(match_value.forwardSRNSContextAcknowledge(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ forwardSRNSContextAcknowledge := "); single_value.field_forwardSRNSContextAcknowledge->log_match(match_value.forwardSRNSContextAcknowledge(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_uERegistrationQueryRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".uERegistrationQueryRequest"); single_value.field_uERegistrationQueryRequest->log_match(match_value.uERegistrationQueryRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ uERegistrationQueryRequest := "); single_value.field_uERegistrationQueryRequest->log_match(match_value.uERegistrationQueryRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_uERegistrationQueryResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".uERegistrationQueryResponse"); single_value.field_uERegistrationQueryResponse->log_match(match_value.uERegistrationQueryResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ uERegistrationQueryResponse := "); single_value.field_uERegistrationQueryResponse->log_match(match_value.uERegistrationQueryResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_ranInformationRelay: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".ranInformationRelay"); single_value.field_ranInformationRelay->log_match(match_value.ranInformationRelay(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ ranInformationRelay := "); single_value.field_ranInformationRelay->log_match(match_value.ranInformationRelay(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSNotificationRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSNotificationRequest"); single_value.field_mBMSNotificationRequest->log_match(match_value.mBMSNotificationRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSNotificationRequest := "); single_value.field_mBMSNotificationRequest->log_match(match_value.mBMSNotificationRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSNotificationResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSNotificationResponse"); single_value.field_mBMSNotificationResponse->log_match(match_value.mBMSNotificationResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSNotificationResponse := "); single_value.field_mBMSNotificationResponse->log_match(match_value.mBMSNotificationResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSNotificationRejectRequest"); single_value.field_mBMSNotificationRejectRequest->log_match(match_value.mBMSNotificationRejectRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSNotificationRejectRequest := "); single_value.field_mBMSNotificationRejectRequest->log_match(match_value.mBMSNotificationRejectRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSNotificationRejectResponse"); single_value.field_mBMSNotificationRejectResponse->log_match(match_value.mBMSNotificationRejectResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSNotificationRejectResponse := "); single_value.field_mBMSNotificationRejectResponse->log_match(match_value.mBMSNotificationRejectResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_createMBMSContextRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".createMBMSContextRequest"); single_value.field_createMBMSContextRequest->log_match(match_value.createMBMSContextRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ createMBMSContextRequest := "); single_value.field_createMBMSContextRequest->log_match(match_value.createMBMSContextRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_createMBMSContextResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".createMBMSContextResponse"); single_value.field_createMBMSContextResponse->log_match(match_value.createMBMSContextResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ createMBMSContextResponse := "); single_value.field_createMBMSContextResponse->log_match(match_value.createMBMSContextResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_updateMBMSContextRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".updateMBMSContextRequest"); single_value.field_updateMBMSContextRequest->log_match(match_value.updateMBMSContextRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ updateMBMSContextRequest := "); single_value.field_updateMBMSContextRequest->log_match(match_value.updateMBMSContextRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_updateMBMSContextResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".updateMBMSContextResponse"); single_value.field_updateMBMSContextResponse->log_match(match_value.updateMBMSContextResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ updateMBMSContextResponse := "); single_value.field_updateMBMSContextResponse->log_match(match_value.updateMBMSContextResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_deleteMBMSContextRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".deleteMBMSContextRequest"); single_value.field_deleteMBMSContextRequest->log_match(match_value.deleteMBMSContextRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ deleteMBMSContextRequest := "); single_value.field_deleteMBMSContextRequest->log_match(match_value.deleteMBMSContextRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_deleteMBMSContextResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".deleteMBMSContextResponse"); single_value.field_deleteMBMSContextResponse->log_match(match_value.deleteMBMSContextResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ deleteMBMSContextResponse := "); single_value.field_deleteMBMSContextResponse->log_match(match_value.deleteMBMSContextResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSRegistrationRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSRegistrationRequest"); single_value.field_mBMSRegistrationRequest->log_match(match_value.mBMSRegistrationRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSRegistrationRequest := "); single_value.field_mBMSRegistrationRequest->log_match(match_value.mBMSRegistrationRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSRegistrationResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSRegistrationResponse"); single_value.field_mBMSRegistrationResponse->log_match(match_value.mBMSRegistrationResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSRegistrationResponse := "); single_value.field_mBMSRegistrationResponse->log_match(match_value.mBMSRegistrationResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSDeRegistrationRequest"); single_value.field_mBMSDeRegistrationRequest->log_match(match_value.mBMSDeRegistrationRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSDeRegistrationRequest := "); single_value.field_mBMSDeRegistrationRequest->log_match(match_value.mBMSDeRegistrationRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSDeRegistrationResponse"); single_value.field_mBMSDeRegistrationResponse->log_match(match_value.mBMSDeRegistrationResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSDeRegistrationResponse := "); single_value.field_mBMSDeRegistrationResponse->log_match(match_value.mBMSDeRegistrationResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSSessionStartRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSSessionStartRequest"); single_value.field_mBMSSessionStartRequest->log_match(match_value.mBMSSessionStartRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSSessionStartRequest := "); single_value.field_mBMSSessionStartRequest->log_match(match_value.mBMSSessionStartRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSSessionStartResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSSessionStartResponse"); single_value.field_mBMSSessionStartResponse->log_match(match_value.mBMSSessionStartResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSSessionStartResponse := "); single_value.field_mBMSSessionStartResponse->log_match(match_value.mBMSSessionStartResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSSessionStopRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSSessionStopRequest"); single_value.field_mBMSSessionStopRequest->log_match(match_value.mBMSSessionStopRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSSessionStopRequest := "); single_value.field_mBMSSessionStopRequest->log_match(match_value.mBMSSessionStopRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSSessionStopResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSSessionStopResponse"); single_value.field_mBMSSessionStopResponse->log_match(match_value.mBMSSessionStopResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSSessionStopResponse := "); single_value.field_mBMSSessionStopResponse->log_match(match_value.mBMSSessionStopResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSSessionUpdateRequest"); single_value.field_mBMSSessionUpdateRequest->log_match(match_value.mBMSSessionUpdateRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSSessionUpdateRequest := "); single_value.field_mBMSSessionUpdateRequest->log_match(match_value.mBMSSessionUpdateRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mBMSSessionUpdateResponse"); single_value.field_mBMSSessionUpdateResponse->log_match(match_value.mBMSSessionUpdateResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mBMSSessionUpdateResponse := "); single_value.field_mBMSSessionUpdateResponse->log_match(match_value.mBMSSessionUpdateResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mS_InfoChangeNotificationRequest"); single_value.field_mS__InfoChangeNotificationRequest->log_match(match_value.mS__InfoChangeNotificationRequest(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mS_InfoChangeNotificationRequest := "); single_value.field_mS__InfoChangeNotificationRequest->log_match(match_value.mS__InfoChangeNotificationRequest(), legacy); TTCN_Logger::log_event_str(" }"); } break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ TTCN_Logger::log_logmatch_info(".mS_InfoChangeNotificationResponse"); single_value.field_mS__InfoChangeNotificationResponse->log_match(match_value.mS__InfoChangeNotificationResponse(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } else { TTCN_Logger::log_event_str("{ mS_InfoChangeNotificationResponse := "); single_value.field_mS__InfoChangeNotificationResponse->log_match(match_value.mS__InfoChangeNotificationResponse(), legacy); TTCN_Logger::log_event_str(" }"); } break; default: TTCN_Logger::print_logmatch_buffer(); TTCN_Logger::log_event_str(""); } } else { TTCN_Logger::print_logmatch_buffer(); match_value.log(); TTCN_Logger::log_event_str(" with "); log(); if (match(match_value, legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } } void GTPC__PDUs_template::encode_text(Text_Buf& text_buf) const { encode_text_base(text_buf); switch (template_selection) { case SPECIFIC_VALUE: text_buf.push_int(single_value.union_selection); switch (single_value.union_selection) { case GTPC__PDUs::ALT_echoRequest: single_value.field_echoRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_echoResponse: single_value.field_echoResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_versionNotSupported: single_value.field_versionNotSupported->encode_text(text_buf); break; case GTPC__PDUs::ALT_createPDPContextRequest: single_value.field_createPDPContextRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_createPDPContextResponse: single_value.field_createPDPContextResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_updatePDPContextRequest: single_value.field_updatePDPContextRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_updatePDPContextResponse: single_value.field_updatePDPContextResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_deletePDPContextRequest: single_value.field_deletePDPContextRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_deletePDPContextResponse: single_value.field_deletePDPContextResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_pdu__NotificationRequest: single_value.field_pdu__NotificationRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_pdu__NotificationResponse: single_value.field_pdu__NotificationResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: single_value.field_pdu__NotificationRejectRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: single_value.field_pdu__NotificationRejectResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: single_value.field_initiatePDPContextActivationRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: single_value.field_initiatePDPContextActivationResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: single_value.field_supportedExtensionHeadersNotification->encode_text(text_buf); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: single_value.field_sendRouteingInformationForGPRSRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: single_value.field_sendRouteingInformationForGPRSResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_failureReportRequest: single_value.field_failureReportRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_failureReportResponse: single_value.field_failureReportResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: single_value.field_noteMS__GPRSPresentRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: single_value.field_noteMS__GPRSPresentResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_identificationRequest: single_value.field_identificationRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_identificationResponse: single_value.field_identificationResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_sgsn__ContextRequest: single_value.field_sgsn__ContextRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_sgsn__ContextResponse: single_value.field_sgsn__ContextResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: single_value.field_sgsn__ContextAcknowledge->encode_text(text_buf); break; case GTPC__PDUs::ALT_forwardRelocationRequest: single_value.field_forwardRelocationRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_forwardRelocationResponse: single_value.field_forwardRelocationResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_forwardRelocationComplete: single_value.field_forwardRelocationComplete->encode_text(text_buf); break; case GTPC__PDUs::ALT_relocationCancelRequest: single_value.field_relocationCancelRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_relocationCancelResponse: single_value.field_relocationCancelResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_forwardSRNSContext: single_value.field_forwardSRNSContext->encode_text(text_buf); break; case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: single_value.field_forwardRelocationCompleteAcknowledge->encode_text(text_buf); break; case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: single_value.field_forwardSRNSContextAcknowledge->encode_text(text_buf); break; case GTPC__PDUs::ALT_uERegistrationQueryRequest: single_value.field_uERegistrationQueryRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_uERegistrationQueryResponse: single_value.field_uERegistrationQueryResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_ranInformationRelay: single_value.field_ranInformationRelay->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSNotificationRequest: single_value.field_mBMSNotificationRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSNotificationResponse: single_value.field_mBMSNotificationResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: single_value.field_mBMSNotificationRejectRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: single_value.field_mBMSNotificationRejectResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_createMBMSContextRequest: single_value.field_createMBMSContextRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_createMBMSContextResponse: single_value.field_createMBMSContextResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_updateMBMSContextRequest: single_value.field_updateMBMSContextRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_updateMBMSContextResponse: single_value.field_updateMBMSContextResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_deleteMBMSContextRequest: single_value.field_deleteMBMSContextRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_deleteMBMSContextResponse: single_value.field_deleteMBMSContextResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSRegistrationRequest: single_value.field_mBMSRegistrationRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSRegistrationResponse: single_value.field_mBMSRegistrationResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: single_value.field_mBMSDeRegistrationRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: single_value.field_mBMSDeRegistrationResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionStartRequest: single_value.field_mBMSSessionStartRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionStartResponse: single_value.field_mBMSSessionStartResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionStopRequest: single_value.field_mBMSSessionStopRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionStopResponse: single_value.field_mBMSSessionStopResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: single_value.field_mBMSSessionUpdateRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: single_value.field_mBMSSessionUpdateResponse->encode_text(text_buf); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: single_value.field_mS__InfoChangeNotificationRequest->encode_text(text_buf); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: single_value.field_mS__InfoChangeNotificationResponse->encode_text(text_buf); break; default: TTCN_error("Internal error: Invalid selector in a specific value when encoding a template of union type @GTPC_Types.GTPC_PDUs."); } case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: text_buf.push_int(value_list.n_values); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].encode_text(text_buf); break; default: TTCN_error("Text encoder: Encoding an uninitialized template of type @GTPC_Types.GTPC_PDUs."); } } void GTPC__PDUs_template::decode_text(Text_Buf& text_buf) { clean_up(); decode_text_base(text_buf); switch (template_selection) { case SPECIFIC_VALUE: { single_value.union_selection = GTPC__PDUs::UNBOUND_VALUE; GTPC__PDUs::union_selection_type new_selection = (GTPC__PDUs::union_selection_type)text_buf.pull_int().get_val(); switch (new_selection) { case GTPC__PDUs::ALT_echoRequest: single_value.field_echoRequest = new EchoRequest_template; single_value.field_echoRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_echoResponse: single_value.field_echoResponse = new EchoResponse_template; single_value.field_echoResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_versionNotSupported: single_value.field_versionNotSupported = new VersionNotSupported_template; single_value.field_versionNotSupported->decode_text(text_buf); break; case GTPC__PDUs::ALT_createPDPContextRequest: single_value.field_createPDPContextRequest = new CreatePDPContextRequest_template; single_value.field_createPDPContextRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_createPDPContextResponse: single_value.field_createPDPContextResponse = new CreatePDPContextResponse_template; single_value.field_createPDPContextResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_updatePDPContextRequest: single_value.field_updatePDPContextRequest = new UpdatePDPContextRequest_template; single_value.field_updatePDPContextRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_updatePDPContextResponse: single_value.field_updatePDPContextResponse = new UpdatePDPContextResponse_template; single_value.field_updatePDPContextResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_deletePDPContextRequest: single_value.field_deletePDPContextRequest = new DeletePDPContextRequest_template; single_value.field_deletePDPContextRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_deletePDPContextResponse: single_value.field_deletePDPContextResponse = new DeletePDPContextResponse_template; single_value.field_deletePDPContextResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_pdu__NotificationRequest: single_value.field_pdu__NotificationRequest = new PDU__NotificationRequest_template; single_value.field_pdu__NotificationRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_pdu__NotificationResponse: single_value.field_pdu__NotificationResponse = new PDU__NotificationResponse_template; single_value.field_pdu__NotificationResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: single_value.field_pdu__NotificationRejectRequest = new PDU__NotificationRejectRequest_template; single_value.field_pdu__NotificationRejectRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: single_value.field_pdu__NotificationRejectResponse = new PDU__NotificationRejectResponse_template; single_value.field_pdu__NotificationRejectResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: single_value.field_initiatePDPContextActivationRequest = new InitiatePDPContextActivationRequest_template; single_value.field_initiatePDPContextActivationRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: single_value.field_initiatePDPContextActivationResponse = new InitiatePDPContextActivationResponse_template; single_value.field_initiatePDPContextActivationResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: single_value.field_supportedExtensionHeadersNotification = new SupportedExtensionHeadersNotification_template; single_value.field_supportedExtensionHeadersNotification->decode_text(text_buf); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: single_value.field_sendRouteingInformationForGPRSRequest = new SendRouteingInformationForGPRSRequest_template; single_value.field_sendRouteingInformationForGPRSRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: single_value.field_sendRouteingInformationForGPRSResponse = new SendRouteingInformationForGPRSResponse_template; single_value.field_sendRouteingInformationForGPRSResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_failureReportRequest: single_value.field_failureReportRequest = new FailureReportRequest_template; single_value.field_failureReportRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_failureReportResponse: single_value.field_failureReportResponse = new FailureReportResponse_template; single_value.field_failureReportResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: single_value.field_noteMS__GPRSPresentRequest = new NoteMS__GPRSPresentRequest_template; single_value.field_noteMS__GPRSPresentRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: single_value.field_noteMS__GPRSPresentResponse = new NoteMS__GPRSPresentResponse_template; single_value.field_noteMS__GPRSPresentResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_identificationRequest: single_value.field_identificationRequest = new IdentificationRequest_template; single_value.field_identificationRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_identificationResponse: single_value.field_identificationResponse = new IdentificationResponse_template; single_value.field_identificationResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_sgsn__ContextRequest: single_value.field_sgsn__ContextRequest = new SGSN__ContextRequest_template; single_value.field_sgsn__ContextRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_sgsn__ContextResponse: single_value.field_sgsn__ContextResponse = new SGSN__ContextResponse_template; single_value.field_sgsn__ContextResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: single_value.field_sgsn__ContextAcknowledge = new SGSN__ContextAcknowledge_template; single_value.field_sgsn__ContextAcknowledge->decode_text(text_buf); break; case GTPC__PDUs::ALT_forwardRelocationRequest: single_value.field_forwardRelocationRequest = new ForwardRelocationRequest_template; single_value.field_forwardRelocationRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_forwardRelocationResponse: single_value.field_forwardRelocationResponse = new ForwardRelocationResponse_template; single_value.field_forwardRelocationResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_forwardRelocationComplete: single_value.field_forwardRelocationComplete = new ForwardRelocationComplete_template; single_value.field_forwardRelocationComplete->decode_text(text_buf); break; case GTPC__PDUs::ALT_relocationCancelRequest: single_value.field_relocationCancelRequest = new RelocationCancelRequest_template; single_value.field_relocationCancelRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_relocationCancelResponse: single_value.field_relocationCancelResponse = new RelocationCancelResponse_template; single_value.field_relocationCancelResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_forwardSRNSContext: single_value.field_forwardSRNSContext = new ForwardSRNSContext_template; single_value.field_forwardSRNSContext->decode_text(text_buf); break; case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: single_value.field_forwardRelocationCompleteAcknowledge = new ForwardRelocationCompleteAcknowledge_template; single_value.field_forwardRelocationCompleteAcknowledge->decode_text(text_buf); break; case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: single_value.field_forwardSRNSContextAcknowledge = new ForwardSRNSContextAcknowledge_template; single_value.field_forwardSRNSContextAcknowledge->decode_text(text_buf); break; case GTPC__PDUs::ALT_uERegistrationQueryRequest: single_value.field_uERegistrationQueryRequest = new UERegistrationQueryRequest_template; single_value.field_uERegistrationQueryRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_uERegistrationQueryResponse: single_value.field_uERegistrationQueryResponse = new UERegistrationQueryResponse_template; single_value.field_uERegistrationQueryResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_ranInformationRelay: single_value.field_ranInformationRelay = new RANInformationRelay_template; single_value.field_ranInformationRelay->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSNotificationRequest: single_value.field_mBMSNotificationRequest = new MBMSNotificationRequest_template; single_value.field_mBMSNotificationRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSNotificationResponse: single_value.field_mBMSNotificationResponse = new MBMSNotificationResponse_template; single_value.field_mBMSNotificationResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: single_value.field_mBMSNotificationRejectRequest = new MBMSNotificationRejectRequest_template; single_value.field_mBMSNotificationRejectRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: single_value.field_mBMSNotificationRejectResponse = new MBMSNotificationRejectResponse_template; single_value.field_mBMSNotificationRejectResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_createMBMSContextRequest: single_value.field_createMBMSContextRequest = new CreateMBMSContextRequest_template; single_value.field_createMBMSContextRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_createMBMSContextResponse: single_value.field_createMBMSContextResponse = new CreateMBMSContextResponse_template; single_value.field_createMBMSContextResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_updateMBMSContextRequest: single_value.field_updateMBMSContextRequest = new UpdateMBMSContextRequest_template; single_value.field_updateMBMSContextRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_updateMBMSContextResponse: single_value.field_updateMBMSContextResponse = new UpdateMBMSContextResponse_template; single_value.field_updateMBMSContextResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_deleteMBMSContextRequest: single_value.field_deleteMBMSContextRequest = new DeleteMBMSContextRequest_template; single_value.field_deleteMBMSContextRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_deleteMBMSContextResponse: single_value.field_deleteMBMSContextResponse = new DeleteMBMSContextResponse_template; single_value.field_deleteMBMSContextResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSRegistrationRequest: single_value.field_mBMSRegistrationRequest = new MBMSRegistrationRequest__gtpc_template; single_value.field_mBMSRegistrationRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSRegistrationResponse: single_value.field_mBMSRegistrationResponse = new MBMSRegistrationResponse__gtpc_template; single_value.field_mBMSRegistrationResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: single_value.field_mBMSDeRegistrationRequest = new MBMSDeRegistrationRequest_template; single_value.field_mBMSDeRegistrationRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: single_value.field_mBMSDeRegistrationResponse = new MBMSDeRegistrationResponse_template; single_value.field_mBMSDeRegistrationResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionStartRequest: single_value.field_mBMSSessionStartRequest = new MBMSSessionStartRequest_template; single_value.field_mBMSSessionStartRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionStartResponse: single_value.field_mBMSSessionStartResponse = new MBMSSessionStartResponse__gtpc_template; single_value.field_mBMSSessionStartResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionStopRequest: single_value.field_mBMSSessionStopRequest = new MBMSSessionStopRequest_template; single_value.field_mBMSSessionStopRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionStopResponse: single_value.field_mBMSSessionStopResponse = new MBMSSessionStopResponse__gtpc_template; single_value.field_mBMSSessionStopResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: single_value.field_mBMSSessionUpdateRequest = new MBMSSessionUpdateRequest_template; single_value.field_mBMSSessionUpdateRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: single_value.field_mBMSSessionUpdateResponse = new MBMSSessionUpdateResponse_template; single_value.field_mBMSSessionUpdateResponse->decode_text(text_buf); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: single_value.field_mS__InfoChangeNotificationRequest = new MS__InfoChangeNotificationRequest_template; single_value.field_mS__InfoChangeNotificationRequest->decode_text(text_buf); break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: single_value.field_mS__InfoChangeNotificationResponse = new MS__InfoChangeNotificationResponse_template; single_value.field_mS__InfoChangeNotificationResponse->decode_text(text_buf); break; default: TTCN_error("Text decoder: Unrecognized union selector was received for a template of type @GTPC_Types.GTPC_PDUs."); } single_value.union_selection = new_selection; } case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: value_list.n_values = text_buf.pull_int().get_val(); value_list.list_value = new GTPC__PDUs_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].decode_text(text_buf); break; default: TTCN_error("Text decoder: Unrecognized selector was received in a template of type @GTPC_Types.GTPC_PDUs."); } } boolean GTPC__PDUs_template::is_present(boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE; return !match_omit(legacy); } boolean GTPC__PDUs_template::match_omit(boolean legacy) const { if (is_ifpresent) return TRUE; switch (template_selection) { case OMIT_VALUE: case ANY_OR_OMIT: return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match_omit() || implication_.implied_template->match_omit(); case VALUE_LIST: case COMPLEMENTED_LIST: if (legacy) { for (unsigned int v_idx=0; v_idx(param.get_id()) != NULL && param.get_id()->next_name()) { char* param_field = param.get_id()->get_current_name(); if (param_field[0] >= '0' && param_field[0] <= '9') { param.error("Unexpected array index in module parameter, expected a valid field" " name for union template type `@GTPC_Types.GTPC_PDUs'"); } if (strcmp("echoRequest", param_field) == 0) { echoRequest().set_param(param); return; } else if (strcmp("echoResponse", param_field) == 0) { echoResponse().set_param(param); return; } else if (strcmp("versionNotSupported", param_field) == 0) { versionNotSupported().set_param(param); return; } else if (strcmp("createPDPContextRequest", param_field) == 0) { createPDPContextRequest().set_param(param); return; } else if (strcmp("createPDPContextResponse", param_field) == 0) { createPDPContextResponse().set_param(param); return; } else if (strcmp("updatePDPContextRequest", param_field) == 0) { updatePDPContextRequest().set_param(param); return; } else if (strcmp("updatePDPContextResponse", param_field) == 0) { updatePDPContextResponse().set_param(param); return; } else if (strcmp("deletePDPContextRequest", param_field) == 0) { deletePDPContextRequest().set_param(param); return; } else if (strcmp("deletePDPContextResponse", param_field) == 0) { deletePDPContextResponse().set_param(param); return; } else if (strcmp("pdu_NotificationRequest", param_field) == 0) { pdu__NotificationRequest().set_param(param); return; } else if (strcmp("pdu_NotificationResponse", param_field) == 0) { pdu__NotificationResponse().set_param(param); return; } else if (strcmp("pdu_NotificationRejectRequest", param_field) == 0) { pdu__NotificationRejectRequest().set_param(param); return; } else if (strcmp("pdu_NotificationRejectResponse", param_field) == 0) { pdu__NotificationRejectResponse().set_param(param); return; } else if (strcmp("initiatePDPContextActivationRequest", param_field) == 0) { initiatePDPContextActivationRequest().set_param(param); return; } else if (strcmp("initiatePDPContextActivationResponse", param_field) == 0) { initiatePDPContextActivationResponse().set_param(param); return; } else if (strcmp("supportedExtensionHeadersNotification", param_field) == 0) { supportedExtensionHeadersNotification().set_param(param); return; } else if (strcmp("sendRouteingInformationForGPRSRequest", param_field) == 0) { sendRouteingInformationForGPRSRequest().set_param(param); return; } else if (strcmp("sendRouteingInformationForGPRSResponse", param_field) == 0) { sendRouteingInformationForGPRSResponse().set_param(param); return; } else if (strcmp("failureReportRequest", param_field) == 0) { failureReportRequest().set_param(param); return; } else if (strcmp("failureReportResponse", param_field) == 0) { failureReportResponse().set_param(param); return; } else if (strcmp("noteMS_GPRSPresentRequest", param_field) == 0) { noteMS__GPRSPresentRequest().set_param(param); return; } else if (strcmp("noteMS_GPRSPresentResponse", param_field) == 0) { noteMS__GPRSPresentResponse().set_param(param); return; } else if (strcmp("identificationRequest", param_field) == 0) { identificationRequest().set_param(param); return; } else if (strcmp("identificationResponse", param_field) == 0) { identificationResponse().set_param(param); return; } else if (strcmp("sgsn_ContextRequest", param_field) == 0) { sgsn__ContextRequest().set_param(param); return; } else if (strcmp("sgsn_ContextResponse", param_field) == 0) { sgsn__ContextResponse().set_param(param); return; } else if (strcmp("sgsn_ContextAcknowledge", param_field) == 0) { sgsn__ContextAcknowledge().set_param(param); return; } else if (strcmp("forwardRelocationRequest", param_field) == 0) { forwardRelocationRequest().set_param(param); return; } else if (strcmp("forwardRelocationResponse", param_field) == 0) { forwardRelocationResponse().set_param(param); return; } else if (strcmp("forwardRelocationComplete", param_field) == 0) { forwardRelocationComplete().set_param(param); return; } else if (strcmp("relocationCancelRequest", param_field) == 0) { relocationCancelRequest().set_param(param); return; } else if (strcmp("relocationCancelResponse", param_field) == 0) { relocationCancelResponse().set_param(param); return; } else if (strcmp("forwardSRNSContext", param_field) == 0) { forwardSRNSContext().set_param(param); return; } else if (strcmp("forwardRelocationCompleteAcknowledge", param_field) == 0) { forwardRelocationCompleteAcknowledge().set_param(param); return; } else if (strcmp("forwardSRNSContextAcknowledge", param_field) == 0) { forwardSRNSContextAcknowledge().set_param(param); return; } else if (strcmp("uERegistrationQueryRequest", param_field) == 0) { uERegistrationQueryRequest().set_param(param); return; } else if (strcmp("uERegistrationQueryResponse", param_field) == 0) { uERegistrationQueryResponse().set_param(param); return; } else if (strcmp("ranInformationRelay", param_field) == 0) { ranInformationRelay().set_param(param); return; } else if (strcmp("mBMSNotificationRequest", param_field) == 0) { mBMSNotificationRequest().set_param(param); return; } else if (strcmp("mBMSNotificationResponse", param_field) == 0) { mBMSNotificationResponse().set_param(param); return; } else if (strcmp("mBMSNotificationRejectRequest", param_field) == 0) { mBMSNotificationRejectRequest().set_param(param); return; } else if (strcmp("mBMSNotificationRejectResponse", param_field) == 0) { mBMSNotificationRejectResponse().set_param(param); return; } else if (strcmp("createMBMSContextRequest", param_field) == 0) { createMBMSContextRequest().set_param(param); return; } else if (strcmp("createMBMSContextResponse", param_field) == 0) { createMBMSContextResponse().set_param(param); return; } else if (strcmp("updateMBMSContextRequest", param_field) == 0) { updateMBMSContextRequest().set_param(param); return; } else if (strcmp("updateMBMSContextResponse", param_field) == 0) { updateMBMSContextResponse().set_param(param); return; } else if (strcmp("deleteMBMSContextRequest", param_field) == 0) { deleteMBMSContextRequest().set_param(param); return; } else if (strcmp("deleteMBMSContextResponse", param_field) == 0) { deleteMBMSContextResponse().set_param(param); return; } else if (strcmp("mBMSRegistrationRequest", param_field) == 0) { mBMSRegistrationRequest().set_param(param); return; } else if (strcmp("mBMSRegistrationResponse", param_field) == 0) { mBMSRegistrationResponse().set_param(param); return; } else if (strcmp("mBMSDeRegistrationRequest", param_field) == 0) { mBMSDeRegistrationRequest().set_param(param); return; } else if (strcmp("mBMSDeRegistrationResponse", param_field) == 0) { mBMSDeRegistrationResponse().set_param(param); return; } else if (strcmp("mBMSSessionStartRequest", param_field) == 0) { mBMSSessionStartRequest().set_param(param); return; } else if (strcmp("mBMSSessionStartResponse", param_field) == 0) { mBMSSessionStartResponse().set_param(param); return; } else if (strcmp("mBMSSessionStopRequest", param_field) == 0) { mBMSSessionStopRequest().set_param(param); return; } else if (strcmp("mBMSSessionStopResponse", param_field) == 0) { mBMSSessionStopResponse().set_param(param); return; } else if (strcmp("mBMSSessionUpdateRequest", param_field) == 0) { mBMSSessionUpdateRequest().set_param(param); return; } else if (strcmp("mBMSSessionUpdateResponse", param_field) == 0) { mBMSSessionUpdateResponse().set_param(param); return; } else if (strcmp("mS_InfoChangeNotificationRequest", param_field) == 0) { mS__InfoChangeNotificationRequest().set_param(param); return; } else if (strcmp("mS_InfoChangeNotificationResponse", param_field) == 0) { mS__InfoChangeNotificationResponse().set_param(param); return; } else param.error("Field `%s' not found in union template type `@GTPC_Types.GTPC_PDUs'", param_field); } param.basic_check(Module_Param::BC_TEMPLATE, "union template"); Module_Param_Ptr m_p = ¶m; switch (m_p->get_type()) { case Module_Param::MP_Omit: *this = OMIT_VALUE; break; case Module_Param::MP_Any: *this = ANY_VALUE; break; case Module_Param::MP_AnyOrNone: *this = ANY_OR_OMIT; break; case Module_Param::MP_List_Template: case Module_Param::MP_ComplementList_Template: case Module_Param::MP_ConjunctList_Template: { GTPC__PDUs_template new_temp; new_temp.set_type(m_p->get_type()==Module_Param::MP_List_Template ? VALUE_LIST : (m_p->get_type() == Module_Param::MP_ConjunctList_Template ? CONJUNCTION_MATCH : COMPLEMENTED_LIST), m_p->get_size()); for (size_t p_i=0; p_iget_size(); p_i++) { new_temp.list_item(p_i).set_param(*m_p->get_elem(p_i)); } *this = new_temp; break; } case Module_Param::MP_Value_List: if (m_p->get_size()==0) break; param.type_error("union template", "@GTPC_Types.GTPC_PDUs"); break; case Module_Param::MP_Assignment_List: { Module_Param* mp_last = m_p->get_elem(m_p->get_size()-1); char* last_name = mp_last->get_id()->get_name(); if (!strcmp(last_name, "echoRequest")) { echoRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "echoResponse")) { echoResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "versionNotSupported")) { versionNotSupported().set_param(*mp_last); break; } if (!strcmp(last_name, "createPDPContextRequest")) { createPDPContextRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "createPDPContextResponse")) { createPDPContextResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "updatePDPContextRequest")) { updatePDPContextRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "updatePDPContextResponse")) { updatePDPContextResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "deletePDPContextRequest")) { deletePDPContextRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "deletePDPContextResponse")) { deletePDPContextResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "pdu_NotificationRequest")) { pdu__NotificationRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "pdu_NotificationResponse")) { pdu__NotificationResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "pdu_NotificationRejectRequest")) { pdu__NotificationRejectRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "pdu_NotificationRejectResponse")) { pdu__NotificationRejectResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "initiatePDPContextActivationRequest")) { initiatePDPContextActivationRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "initiatePDPContextActivationResponse")) { initiatePDPContextActivationResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "supportedExtensionHeadersNotification")) { supportedExtensionHeadersNotification().set_param(*mp_last); break; } if (!strcmp(last_name, "sendRouteingInformationForGPRSRequest")) { sendRouteingInformationForGPRSRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "sendRouteingInformationForGPRSResponse")) { sendRouteingInformationForGPRSResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "failureReportRequest")) { failureReportRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "failureReportResponse")) { failureReportResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "noteMS_GPRSPresentRequest")) { noteMS__GPRSPresentRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "noteMS_GPRSPresentResponse")) { noteMS__GPRSPresentResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "identificationRequest")) { identificationRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "identificationResponse")) { identificationResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "sgsn_ContextRequest")) { sgsn__ContextRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "sgsn_ContextResponse")) { sgsn__ContextResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "sgsn_ContextAcknowledge")) { sgsn__ContextAcknowledge().set_param(*mp_last); break; } if (!strcmp(last_name, "forwardRelocationRequest")) { forwardRelocationRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "forwardRelocationResponse")) { forwardRelocationResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "forwardRelocationComplete")) { forwardRelocationComplete().set_param(*mp_last); break; } if (!strcmp(last_name, "relocationCancelRequest")) { relocationCancelRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "relocationCancelResponse")) { relocationCancelResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "forwardSRNSContext")) { forwardSRNSContext().set_param(*mp_last); break; } if (!strcmp(last_name, "forwardRelocationCompleteAcknowledge")) { forwardRelocationCompleteAcknowledge().set_param(*mp_last); break; } if (!strcmp(last_name, "forwardSRNSContextAcknowledge")) { forwardSRNSContextAcknowledge().set_param(*mp_last); break; } if (!strcmp(last_name, "uERegistrationQueryRequest")) { uERegistrationQueryRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "uERegistrationQueryResponse")) { uERegistrationQueryResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "ranInformationRelay")) { ranInformationRelay().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSNotificationRequest")) { mBMSNotificationRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSNotificationResponse")) { mBMSNotificationResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSNotificationRejectRequest")) { mBMSNotificationRejectRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSNotificationRejectResponse")) { mBMSNotificationRejectResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "createMBMSContextRequest")) { createMBMSContextRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "createMBMSContextResponse")) { createMBMSContextResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "updateMBMSContextRequest")) { updateMBMSContextRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "updateMBMSContextResponse")) { updateMBMSContextResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "deleteMBMSContextRequest")) { deleteMBMSContextRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "deleteMBMSContextResponse")) { deleteMBMSContextResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSRegistrationRequest")) { mBMSRegistrationRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSRegistrationResponse")) { mBMSRegistrationResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSDeRegistrationRequest")) { mBMSDeRegistrationRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSDeRegistrationResponse")) { mBMSDeRegistrationResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSSessionStartRequest")) { mBMSSessionStartRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSSessionStartResponse")) { mBMSSessionStartResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSSessionStopRequest")) { mBMSSessionStopRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSSessionStopResponse")) { mBMSSessionStopResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSSessionUpdateRequest")) { mBMSSessionUpdateRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "mBMSSessionUpdateResponse")) { mBMSSessionUpdateResponse().set_param(*mp_last); break; } if (!strcmp(last_name, "mS_InfoChangeNotificationRequest")) { mS__InfoChangeNotificationRequest().set_param(*mp_last); break; } if (!strcmp(last_name, "mS_InfoChangeNotificationResponse")) { mS__InfoChangeNotificationResponse().set_param(*mp_last); break; } mp_last->error("Field %s does not exist in type @GTPC_Types.GTPC_PDUs.", last_name); } break; case Module_Param::MP_Implication_Template: { GTPC__PDUs_template* precondition = new GTPC__PDUs_template; precondition->set_param(*m_p->get_elem(0)); GTPC__PDUs_template* implied_template = new GTPC__PDUs_template; implied_template->set_param(*m_p->get_elem(1)); *this = GTPC__PDUs_template(precondition, implied_template); } break; default: param.type_error("union template", "@GTPC_Types.GTPC_PDUs"); } is_ifpresent = param.get_ifpresent(); } void GTPC__PDUs_template::check_restriction(template_res t_res, const char* t_name, boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return; switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) { case TR_OMIT: if (template_selection==OMIT_VALUE) return; case TR_VALUE: if (template_selection!=SPECIFIC_VALUE || is_ifpresent) break; switch (single_value.union_selection) { case GTPC__PDUs::ALT_echoRequest: single_value.field_echoRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_echoResponse: single_value.field_echoResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_versionNotSupported: single_value.field_versionNotSupported->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_createPDPContextRequest: single_value.field_createPDPContextRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_createPDPContextResponse: single_value.field_createPDPContextResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_updatePDPContextRequest: single_value.field_updatePDPContextRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_updatePDPContextResponse: single_value.field_updatePDPContextResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_deletePDPContextRequest: single_value.field_deletePDPContextRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_deletePDPContextResponse: single_value.field_deletePDPContextResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_pdu__NotificationRequest: single_value.field_pdu__NotificationRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_pdu__NotificationResponse: single_value.field_pdu__NotificationResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: single_value.field_pdu__NotificationRejectRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: single_value.field_pdu__NotificationRejectResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: single_value.field_initiatePDPContextActivationRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: single_value.field_initiatePDPContextActivationResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: single_value.field_supportedExtensionHeadersNotification->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: single_value.field_sendRouteingInformationForGPRSRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: single_value.field_sendRouteingInformationForGPRSResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_failureReportRequest: single_value.field_failureReportRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_failureReportResponse: single_value.field_failureReportResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: single_value.field_noteMS__GPRSPresentRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: single_value.field_noteMS__GPRSPresentResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_identificationRequest: single_value.field_identificationRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_identificationResponse: single_value.field_identificationResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_sgsn__ContextRequest: single_value.field_sgsn__ContextRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_sgsn__ContextResponse: single_value.field_sgsn__ContextResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: single_value.field_sgsn__ContextAcknowledge->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_forwardRelocationRequest: single_value.field_forwardRelocationRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_forwardRelocationResponse: single_value.field_forwardRelocationResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_forwardRelocationComplete: single_value.field_forwardRelocationComplete->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_relocationCancelRequest: single_value.field_relocationCancelRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_relocationCancelResponse: single_value.field_relocationCancelResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_forwardSRNSContext: single_value.field_forwardSRNSContext->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: single_value.field_forwardRelocationCompleteAcknowledge->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: single_value.field_forwardSRNSContextAcknowledge->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_uERegistrationQueryRequest: single_value.field_uERegistrationQueryRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_uERegistrationQueryResponse: single_value.field_uERegistrationQueryResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_ranInformationRelay: single_value.field_ranInformationRelay->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSNotificationRequest: single_value.field_mBMSNotificationRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSNotificationResponse: single_value.field_mBMSNotificationResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: single_value.field_mBMSNotificationRejectRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: single_value.field_mBMSNotificationRejectResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_createMBMSContextRequest: single_value.field_createMBMSContextRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_createMBMSContextResponse: single_value.field_createMBMSContextResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_updateMBMSContextRequest: single_value.field_updateMBMSContextRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_updateMBMSContextResponse: single_value.field_updateMBMSContextResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_deleteMBMSContextRequest: single_value.field_deleteMBMSContextRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_deleteMBMSContextResponse: single_value.field_deleteMBMSContextResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSRegistrationRequest: single_value.field_mBMSRegistrationRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSRegistrationResponse: single_value.field_mBMSRegistrationResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: single_value.field_mBMSDeRegistrationRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: single_value.field_mBMSDeRegistrationResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSSessionStartRequest: single_value.field_mBMSSessionStartRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSSessionStartResponse: single_value.field_mBMSSessionStartResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSSessionStopRequest: single_value.field_mBMSSessionStopRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSSessionStopResponse: single_value.field_mBMSSessionStopResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: single_value.field_mBMSSessionUpdateRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: single_value.field_mBMSSessionUpdateResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: single_value.field_mS__InfoChangeNotificationRequest->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: single_value.field_mS__InfoChangeNotificationResponse->check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); return; default: TTCN_error("Internal error: Invalid selector in a specific value when performing check_restriction operation on a template of union type @GTPC_Types.GTPC_PDUs."); } case TR_PRESENT: if (!match_omit(legacy)) return; break; default: return; } TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@GTPC_Types.GTPC_PDUs"); } PDU__GTPC::PDU__GTPC() { } PDU__GTPC::PDU__GTPC(const BITSTRING& par_pn__bit, const BITSTRING& par_s__bit, const BITSTRING& par_e__bit, const BITSTRING& par_spare, const BITSTRING& par_pt, const BITSTRING& par_version, const OCTETSTRING& par_messageType, const INTEGER& par_lengthf, const OCTETSTRING& par_teid, const OPTIONAL< GTPC__Header__optional__part >& par_opt__part, const GTPC__PDUs& par_gtpc__pdu) : field_pn__bit(par_pn__bit), field_s__bit(par_s__bit), field_e__bit(par_e__bit), field_spare(par_spare), field_pt(par_pt), field_version(par_version), field_messageType(par_messageType), field_lengthf(par_lengthf), field_teid(par_teid), field_opt__part(par_opt__part), field_gtpc__pdu(par_gtpc__pdu) { } PDU__GTPC::PDU__GTPC(const PDU__GTPC& other_value) { if(!other_value.is_bound()) TTCN_error("Copying an unbound value of type @GTPC_Types.PDU_GTPC."); if (other_value.pn__bit().is_bound()) field_pn__bit = other_value.pn__bit(); else field_pn__bit.clean_up(); if (other_value.s__bit().is_bound()) field_s__bit = other_value.s__bit(); else field_s__bit.clean_up(); if (other_value.e__bit().is_bound()) field_e__bit = other_value.e__bit(); else field_e__bit.clean_up(); if (other_value.spare().is_bound()) field_spare = other_value.spare(); else field_spare.clean_up(); if (other_value.pt().is_bound()) field_pt = other_value.pt(); else field_pt.clean_up(); if (other_value.version().is_bound()) field_version = other_value.version(); else field_version.clean_up(); if (other_value.messageType().is_bound()) field_messageType = other_value.messageType(); else field_messageType.clean_up(); if (other_value.lengthf().is_bound()) field_lengthf = other_value.lengthf(); else field_lengthf.clean_up(); if (other_value.teid().is_bound()) field_teid = other_value.teid(); else field_teid.clean_up(); if (other_value.opt__part().is_bound()) field_opt__part = other_value.opt__part(); else field_opt__part.clean_up(); if (other_value.gtpc__pdu().is_bound()) field_gtpc__pdu = other_value.gtpc__pdu(); else field_gtpc__pdu.clean_up(); } void PDU__GTPC::clean_up() { field_pn__bit.clean_up(); field_s__bit.clean_up(); field_e__bit.clean_up(); field_spare.clean_up(); field_pt.clean_up(); field_version.clean_up(); field_messageType.clean_up(); field_lengthf.clean_up(); field_teid.clean_up(); field_opt__part.clean_up(); field_gtpc__pdu.clean_up(); } const TTCN_Typedescriptor_t* PDU__GTPC::get_descriptor() const { return &PDU__GTPC_descr_; } PDU__GTPC& PDU__GTPC::operator=(const PDU__GTPC& other_value) { if (this != &other_value) { if(!other_value.is_bound()) TTCN_error("Assignment of an unbound value of type @GTPC_Types.PDU_GTPC."); if (other_value.pn__bit().is_bound()) field_pn__bit = other_value.pn__bit(); else field_pn__bit.clean_up(); if (other_value.s__bit().is_bound()) field_s__bit = other_value.s__bit(); else field_s__bit.clean_up(); if (other_value.e__bit().is_bound()) field_e__bit = other_value.e__bit(); else field_e__bit.clean_up(); if (other_value.spare().is_bound()) field_spare = other_value.spare(); else field_spare.clean_up(); if (other_value.pt().is_bound()) field_pt = other_value.pt(); else field_pt.clean_up(); if (other_value.version().is_bound()) field_version = other_value.version(); else field_version.clean_up(); if (other_value.messageType().is_bound()) field_messageType = other_value.messageType(); else field_messageType.clean_up(); if (other_value.lengthf().is_bound()) field_lengthf = other_value.lengthf(); else field_lengthf.clean_up(); if (other_value.teid().is_bound()) field_teid = other_value.teid(); else field_teid.clean_up(); if (other_value.opt__part().is_bound()) field_opt__part = other_value.opt__part(); else field_opt__part.clean_up(); if (other_value.gtpc__pdu().is_bound()) field_gtpc__pdu = other_value.gtpc__pdu(); else field_gtpc__pdu.clean_up(); } return *this; } boolean PDU__GTPC::operator==(const PDU__GTPC& other_value) const { return field_pn__bit==other_value.field_pn__bit && field_s__bit==other_value.field_s__bit && field_e__bit==other_value.field_e__bit && field_spare==other_value.field_spare && field_pt==other_value.field_pt && field_version==other_value.field_version && field_messageType==other_value.field_messageType && field_lengthf==other_value.field_lengthf && field_teid==other_value.field_teid && field_opt__part==other_value.field_opt__part && field_gtpc__pdu==other_value.field_gtpc__pdu; } boolean PDU__GTPC::is_bound() const { return (field_pn__bit.is_bound()) || (field_s__bit.is_bound()) || (field_e__bit.is_bound()) || (field_spare.is_bound()) || (field_pt.is_bound()) || (field_version.is_bound()) || (field_messageType.is_bound()) || (field_lengthf.is_bound()) || (field_teid.is_bound()) || (OPTIONAL_OMIT == field_opt__part.get_selection() || field_opt__part.is_bound()) || (field_gtpc__pdu.is_bound()); } boolean PDU__GTPC::is_value() const { return field_pn__bit.is_value() && field_s__bit.is_value() && field_e__bit.is_value() && field_spare.is_value() && field_pt.is_value() && field_version.is_value() && field_messageType.is_value() && field_lengthf.is_value() && field_teid.is_value() && (OPTIONAL_OMIT == field_opt__part.get_selection() || field_opt__part.is_value()) && field_gtpc__pdu.is_value(); } int PDU__GTPC::size_of() const { int ret_val = 10; if (field_opt__part.ispresent()) ret_val++; return ret_val; } void PDU__GTPC::log() const { if (!is_bound()) { TTCN_Logger::log_event_unbound(); return; } TTCN_Logger::log_event_str("{ pn_bit := "); field_pn__bit.log(); TTCN_Logger::log_event_str(", s_bit := "); field_s__bit.log(); TTCN_Logger::log_event_str(", e_bit := "); field_e__bit.log(); TTCN_Logger::log_event_str(", spare := "); field_spare.log(); TTCN_Logger::log_event_str(", pt := "); field_pt.log(); TTCN_Logger::log_event_str(", version := "); field_version.log(); TTCN_Logger::log_event_str(", messageType := "); field_messageType.log(); TTCN_Logger::log_event_str(", lengthf := "); field_lengthf.log(); TTCN_Logger::log_event_str(", teid := "); field_teid.log(); TTCN_Logger::log_event_str(", opt_part := "); field_opt__part.log(); TTCN_Logger::log_event_str(", gtpc_pdu := "); field_gtpc__pdu.log(); TTCN_Logger::log_event_str(" }"); } void PDU__GTPC::set_implicit_omit() { if (pn__bit().is_bound()) pn__bit().set_implicit_omit(); if (s__bit().is_bound()) s__bit().set_implicit_omit(); if (e__bit().is_bound()) e__bit().set_implicit_omit(); if (spare().is_bound()) spare().set_implicit_omit(); if (pt().is_bound()) pt().set_implicit_omit(); if (version().is_bound()) version().set_implicit_omit(); if (messageType().is_bound()) messageType().set_implicit_omit(); if (lengthf().is_bound()) lengthf().set_implicit_omit(); if (teid().is_bound()) teid().set_implicit_omit(); if (!opt__part().is_bound()) opt__part() = OMIT_VALUE; else opt__part().set_implicit_omit(); if (gtpc__pdu().is_bound()) gtpc__pdu().set_implicit_omit(); } void PDU__GTPC::set_param(Module_Param& param) { param.basic_check(Module_Param::BC_VALUE, "record value"); switch (param.get_type()) { case Module_Param::MP_Value_List: if (110 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) pn__bit().set_param(*param.get_elem(0)); if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) s__bit().set_param(*param.get_elem(1)); if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) e__bit().set_param(*param.get_elem(2)); if (param.get_size()>3 && param.get_elem(3)->get_type()!=Module_Param::MP_NotUsed) spare().set_param(*param.get_elem(3)); if (param.get_size()>4 && param.get_elem(4)->get_type()!=Module_Param::MP_NotUsed) pt().set_param(*param.get_elem(4)); if (param.get_size()>5 && param.get_elem(5)->get_type()!=Module_Param::MP_NotUsed) version().set_param(*param.get_elem(5)); if (param.get_size()>6 && param.get_elem(6)->get_type()!=Module_Param::MP_NotUsed) messageType().set_param(*param.get_elem(6)); if (param.get_size()>7 && param.get_elem(7)->get_type()!=Module_Param::MP_NotUsed) lengthf().set_param(*param.get_elem(7)); if (param.get_size()>8 && param.get_elem(8)->get_type()!=Module_Param::MP_NotUsed) teid().set_param(*param.get_elem(8)); if (param.get_size()>9 && param.get_elem(9)->get_type()!=Module_Param::MP_NotUsed) opt__part().set_param(*param.get_elem(9)); if (param.get_size()>10 && param.get_elem(10)->get_type()!=Module_Param::MP_NotUsed) gtpc__pdu().set_param(*param.get_elem(10)); break; case Module_Param::MP_Assignment_List: { Vector value_used(param.get_size()); value_used.resize(param.get_size(), FALSE); for (size_t val_idx=0; val_idxget_id()->get_name(), "pn_bit")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { pn__bit().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "s_bit")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { s__bit().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "e_bit")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { e__bit().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "spare")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { spare().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "pt")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { pt().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "version")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { version().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "messageType")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { messageType().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "lengthf")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { lengthf().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "teid")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { teid().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "opt_part")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { opt__part().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "gtpc_pdu")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { gtpc__pdu().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxerror("Non existent field name in type @GTPC_Types.PDU_GTPC: %s", curr_param->get_id()->get_name()); break; } } break; default: param.type_error("record value", "@GTPC_Types.PDU_GTPC"); } } void PDU__GTPC::encode_text(Text_Buf& text_buf) const { field_pn__bit.encode_text(text_buf); field_s__bit.encode_text(text_buf); field_e__bit.encode_text(text_buf); field_spare.encode_text(text_buf); field_pt.encode_text(text_buf); field_version.encode_text(text_buf); field_messageType.encode_text(text_buf); field_lengthf.encode_text(text_buf); field_teid.encode_text(text_buf); field_opt__part.encode_text(text_buf); field_gtpc__pdu.encode_text(text_buf); } void PDU__GTPC::decode_text(Text_Buf& text_buf) { field_pn__bit.decode_text(text_buf); field_s__bit.decode_text(text_buf); field_e__bit.decode_text(text_buf); field_spare.decode_text(text_buf); field_pt.decode_text(text_buf); field_version.decode_text(text_buf); field_messageType.decode_text(text_buf); field_lengthf.decode_text(text_buf); field_teid.decode_text(text_buf); field_opt__part.decode_text(text_buf); field_gtpc__pdu.decode_text(text_buf); } void PDU__GTPC::encode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) const { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-encoding type '%s': ", p_td.name); unsigned BER_coding=va_arg(pvar, unsigned); BER_encode_chk_coding(BER_coding); ASN_BER_TLV_t *tlv=BER_encode_TLV(p_td, BER_coding); tlv->put_in_buffer(p_buf); ASN_BER_TLV_t::destruct(tlv); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-encoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); RAW_enc_tr_pos rp; rp.level=0; rp.pos=NULL; RAW_enc_tree root(FALSE, NULL, &rp, 1, p_td.raw); RAW_encode(p_td, root); root.put_to_buf(p_buf); break;} case TTCN_EncDec::CT_TEXT: { TTCN_EncDec_ErrorContext ec("While TEXT-encoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); TEXT_encode(p_td,p_buf); break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-encoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XER_encode(*(p_td.xer),p_buf, XER_coding, 0, 0, 0); p_buf.put_c('\n'); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-encoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok(va_arg(pvar, int) != 0); JSON_encode(p_td, tok, FALSE); p_buf.put_s(tok.get_buffer_length(), (const unsigned char*)tok.get_buffer()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-encoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_encode(p_td, p_buf); break;} default: TTCN_error("Unknown coding method requested to encode type '%s'", p_td.name); } va_end(pvar); } void PDU__GTPC::decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-decoding type '%s': ", p_td.name); unsigned L_form=va_arg(pvar, unsigned); ASN_BER_TLV_t tlv; BER_decode_str2TLV(p_buf, tlv, L_form); BER_decode_TLV(p_td, tlv, L_form); if(tlv.isComplete) p_buf.increase_pos(tlv.get_len()); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-decoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); raw_order_t r_order; switch(p_td.raw->top_bit_order) { case TOP_BIT_LEFT: r_order=ORDER_LSB; break; case TOP_BIT_RIGHT: default: r_order=ORDER_MSB; } int rawr = RAW_decode(p_td, p_buf, p_buf.get_len()*8, r_order); if(rawr<0) switch (-rawr) { case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: ec.error((TTCN_EncDec::error_type_t)-rawr, "Can not decode type '%s', because incomplete message was received", p_td.name); break; case 1: default: ec.error(TTCN_EncDec::ET_INVAL_MSG, "Can not decode type '%s', because invalid message was received", p_td.name); break; } break;} case TTCN_EncDec::CT_TEXT: { Limit_Token_List limit; TTCN_EncDec_ErrorContext ec("While TEXT-decoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); const unsigned char *b_data=p_buf.get_data(); int null_added=0; if(b_data[p_buf.get_len()-1]!='\0'){ null_added=1; p_buf.set_pos(p_buf.get_len()); p_buf.put_zero(8,ORDER_LSB); p_buf.rewind(); } if(TEXT_decode(p_td,p_buf,limit)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); if(null_added){ size_t actpos=p_buf.get_pos(); p_buf.set_pos(p_buf.get_len()-1); p_buf.cut_end(); p_buf.set_pos(actpos); } break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-decoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XmlReaderWrap reader(p_buf); for (int rd_ok=reader.Read(); rd_ok==1; rd_ok=reader.Read()) { if (reader.NodeType() == XML_READER_TYPE_ELEMENT) break; } XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL, XER_NONE, 0); size_t bytes = reader.ByteConsumed(); p_buf.set_pos(bytes); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-decoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok((const char*)p_buf.get_data(), p_buf.get_len()); if(JSON_decode(p_td, tok, FALSE, FALSE)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); p_buf.set_pos(tok.get_buf_pos()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-decoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_struct p_oer; OER_decode(p_td, p_buf, p_oer); break;} default: TTCN_error("Unknown coding method requested to decode type '%s'", p_td.name); } va_end(pvar); } int PDU__GTPC::RAW_decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int limit, raw_order_t top_bit_ord, boolean no_err, int, boolean, const RAW_Force_Omit* force_omit) { (void)no_err; int prepaddlength=p_buf.increase_pos_padd(p_td.raw->prepadding); limit-=prepaddlength; size_t last_decoded_pos = p_buf.get_pos_bit(); int decoded_length = 0; int decoded_field_length = 0; raw_order_t local_top_order; int selected_field = -1; if(p_td.raw->top_bit_order==TOP_BIT_INHERITED)local_top_order=top_bit_ord; else if(p_td.raw->top_bit_order==TOP_BIT_RIGHT)local_top_order=ORDER_MSB; else local_top_order=ORDER_LSB; int value_of_length_field7 = 0; RAW_Force_Omit field_0_force_omit(0, force_omit, General__Types::BIT1_descr_.raw->forceomit); decoded_field_length = field_pn__bit.RAW_decode(General__Types::BIT1_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_0_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); RAW_Force_Omit field_1_force_omit(1, force_omit, General__Types::BIT1_descr_.raw->forceomit); decoded_field_length = field_s__bit.RAW_decode(General__Types::BIT1_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_1_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); RAW_Force_Omit field_2_force_omit(2, force_omit, General__Types::BIT1_descr_.raw->forceomit); decoded_field_length = field_e__bit.RAW_decode(General__Types::BIT1_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_2_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); RAW_Force_Omit field_3_force_omit(3, force_omit, General__Types::BIT1_descr_.raw->forceomit); decoded_field_length = field_spare.RAW_decode(General__Types::BIT1_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_3_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); RAW_Force_Omit field_4_force_omit(4, force_omit, General__Types::BIT1_descr_.raw->forceomit); decoded_field_length = field_pt.RAW_decode(General__Types::BIT1_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_4_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); RAW_Force_Omit field_5_force_omit(5, force_omit, General__Types::BIT3_descr_.raw->forceomit); decoded_field_length = field_version.RAW_decode(General__Types::BIT3_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_5_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); RAW_Force_Omit field_6_force_omit(6, force_omit, General__Types::OCT1_descr_.raw->forceomit); decoded_field_length = field_messageType.RAW_decode(General__Types::OCT1_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_6_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); RAW_Force_Omit field_7_force_omit(7, force_omit, PDU__GTPC_lengthf_descr_.raw->forceomit); decoded_field_length = field_lengthf.RAW_decode(PDU__GTPC_lengthf_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_7_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); INTEGER tmp7 = field_lengthf.convert_to_Integer(PDU__GTPC_lengthf_descr_); field_lengthf = tmp7; value_of_length_field7 += tmp7.get_long_long_val() * 8; RAW_Force_Omit field_8_force_omit(8, force_omit, General__Types::OCT4_descr_.raw->forceomit); decoded_field_length = field_teid.RAW_decode(General__Types::OCT4_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_8_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); if (limit > 0 && value_of_length_field7 > 0 && (field_pn__bit == bs_3 || field_s__bit == bs_3 || field_e__bit == bs_3)){ if (force_omit != NULL && (*force_omit)(9)) { field_opt__part = OMIT_VALUE; } else { size_t fl_start_pos = p_buf.get_pos_bit(); RAW_Force_Omit field_9_force_omit(9, force_omit, PDU__GTPC_opt__part_descr_.raw->forceomit); decoded_field_length = field_opt__part().RAW_decode(PDU__GTPC_opt__part_descr_, p_buf, min_of_ints(2, limit, value_of_length_field7), local_top_order, TRUE, -1, TRUE, &field_9_force_omit); if (decoded_field_length < 1) { field_opt__part = OMIT_VALUE; p_buf.set_pos_bit(fl_start_pos); } else { decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); value_of_length_field7 -= decoded_field_length; } } } else field_opt__part=OMIT_VALUE; if (field_messageType == os_13) selected_field = 0; else if (field_messageType == os_2) selected_field = 1; else if (field_messageType == os_3) selected_field = 2; else if (field_messageType == os_5) selected_field = 3; else if (field_messageType == os_6) selected_field = 4; else if (field_messageType == os_81) selected_field = 5; else if (field_messageType == os_48) selected_field = 6; else if (field_messageType == os_7) selected_field = 7; else if (field_messageType == os_83) selected_field = 8; else if (field_messageType == os_61) selected_field = 13; else if (field_messageType == os_62) selected_field = 14; else if (field_messageType == os_9) selected_field = 9; else if (field_messageType == os_10) selected_field = 10; else if (field_messageType == os_51) selected_field = 11; else if (field_messageType == os_131) selected_field = 12; else if (field_messageType == os_132) selected_field = 15; else if (field_messageType == os_133) selected_field = 16; else if (field_messageType == os_11) selected_field = 17; else if (field_messageType == os_134) selected_field = 18; else if (field_messageType == os_135) selected_field = 19; else if (field_messageType == os_136) selected_field = 20; else if (field_messageType == os_137) selected_field = 21; else if (field_messageType == os_138) selected_field = 22; else if (field_messageType == os_139) selected_field = 23; else if (field_messageType == os_140) selected_field = 24; else if (field_messageType == os_141) selected_field = 25; else if (field_messageType == os_142) selected_field = 26; else if (field_messageType == os_143) selected_field = 27; else if (field_messageType == os_144) selected_field = 28; else if (field_messageType == os_145) selected_field = 29; else if (field_messageType == os_146) selected_field = 30; else if (field_messageType == os_147) selected_field = 31; else if (field_messageType == os_148) selected_field = 32; else if (field_messageType == os_149) selected_field = 33; else if (field_messageType == os_150) selected_field = 34; else if (field_messageType == os_151) selected_field = 35; else if (field_messageType == os_152) selected_field = 36; else if (field_messageType == os_153) selected_field = 37; else if (field_messageType == os_154) selected_field = 38; else if (field_messageType == os_155) selected_field = 39; else if (field_messageType == os_156) selected_field = 40; else if (field_messageType == os_157) selected_field = 41; else if (field_messageType == os_158) selected_field = 42; else if (field_messageType == os_159) selected_field = 43; else if (field_messageType == os_160) selected_field = 44; else if (field_messageType == os_161) selected_field = 45; else if (field_messageType == os_162) selected_field = 46; else if (field_messageType == os_163) selected_field = 47; else if (field_messageType == os_110) selected_field = 48; else if (field_messageType == os_109) selected_field = 49; else if (field_messageType == os_111) selected_field = 50; else if (field_messageType == os_112) selected_field = 51; else if (field_messageType == os_113) selected_field = 52; else if (field_messageType == os_164) selected_field = 53; else if (field_messageType == os_165) selected_field = 54; else if (field_messageType == os_166) selected_field = 55; else if (field_messageType == os_167) selected_field = 56; else if (field_messageType == os_168) selected_field = 57; else if (field_messageType == os_15) selected_field = 58; else if (field_messageType == os_65) selected_field = 59; else selected_field = -1; RAW_Force_Omit field_10_force_omit(10, force_omit, PDU__GTPC_gtpc__pdu_descr_.raw->forceomit); decoded_field_length = field_gtpc__pdu.RAW_decode(PDU__GTPC_gtpc__pdu_descr_, p_buf, min_of_ints(2, limit, value_of_length_field7), local_top_order, no_err, selected_field, TRUE, &field_10_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); value_of_length_field7 -= decoded_field_length; p_buf.set_pos_bit(last_decoded_pos); return decoded_length+prepaddlength+p_buf.increase_pos_padd(p_td.raw->padding); } int PDU__GTPC::RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree& myleaf) const { if (!is_bound()) TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_UNBOUND, "Encoding an unbound value."); int encoded_length = 0; myleaf.isleaf = FALSE; myleaf.body.node.num_of_nodes = 11; myleaf.body.node.nodes = init_nodes_of_enc_tree(11); myleaf.body.node.nodes[0] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 0, General__Types::BIT1_descr_.raw); myleaf.body.node.nodes[1] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 1, General__Types::BIT1_descr_.raw); myleaf.body.node.nodes[2] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 2, General__Types::BIT1_descr_.raw); myleaf.body.node.nodes[3] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 3, General__Types::BIT1_descr_.raw); myleaf.body.node.nodes[4] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 4, General__Types::BIT1_descr_.raw); myleaf.body.node.nodes[5] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 5, General__Types::BIT3_descr_.raw); myleaf.body.node.nodes[6] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 6, General__Types::OCT1_descr_.raw); myleaf.body.node.nodes[7] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 7, PDU__GTPC_lengthf_descr_.raw); myleaf.body.node.nodes[8] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 8, General__Types::OCT4_descr_.raw); if (field_opt__part.ispresent()) { myleaf.body.node.nodes[9] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 9, PDU__GTPC_opt__part_descr_.raw); } else myleaf.body.node.nodes[9] = NULL; myleaf.body.node.nodes[10] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 10, PDU__GTPC_gtpc__pdu_descr_.raw); encoded_length += field_pn__bit.RAW_encode(General__Types::BIT1_descr_, *myleaf.body.node.nodes[0]); encoded_length += field_s__bit.RAW_encode(General__Types::BIT1_descr_, *myleaf.body.node.nodes[1]); encoded_length += field_e__bit.RAW_encode(General__Types::BIT1_descr_, *myleaf.body.node.nodes[2]); encoded_length += field_spare.RAW_encode(General__Types::BIT1_descr_, *myleaf.body.node.nodes[3]); encoded_length += field_pt.RAW_encode(General__Types::BIT1_descr_, *myleaf.body.node.nodes[4]); encoded_length += field_version.RAW_encode(General__Types::BIT3_descr_, *myleaf.body.node.nodes[5]); encoded_length += field_messageType.RAW_encode(General__Types::OCT1_descr_, *myleaf.body.node.nodes[6]); encoded_length += 16; myleaf.body.node.nodes[7]->calc = CALC_LENGTH; myleaf.body.node.nodes[7]->coding_descr = &PDU__GTPC_lengthf_descr_; myleaf.body.node.nodes[7]->calcof.lengthto.num_of_fields = 2; myleaf.body.node.nodes[7]->calcof.lengthto.unit = 8; myleaf.body.node.nodes[7]->calcof.lengthto.offset = 0; myleaf.body.node.nodes[7]->calcof.lengthto.fields = init_lengthto_fields_list(2); myleaf.body.node.nodes[7]->length = 16; if (field_opt__part.ispresent()) { myleaf.body.node.nodes[7]->calcof.lengthto.fields[0].level = myleaf.body.node.nodes[9]->curr_pos.level; myleaf.body.node.nodes[7]->calcof.lengthto.fields[0].pos = myleaf.body.node.nodes[9]->curr_pos.pos; } else { myleaf.body.node.nodes[7]->calcof.lengthto.fields[0].level = 0; myleaf.body.node.nodes[7]->calcof.lengthto.fields[0].pos = 0; } myleaf.body.node.nodes[7]->calcof.lengthto.fields[1].level = myleaf.body.node.nodes[10]->curr_pos.level; myleaf.body.node.nodes[7]->calcof.lengthto.fields[1].pos = myleaf.body.node.nodes[10]->curr_pos.pos; encoded_length += field_teid.RAW_encode(General__Types::OCT4_descr_, *myleaf.body.node.nodes[8]); if (field_opt__part.ispresent()) { encoded_length += field_opt__part().RAW_encode(PDU__GTPC_opt__part_descr_, *myleaf.body.node.nodes[9]); } encoded_length += field_gtpc__pdu.RAW_encode(PDU__GTPC_gtpc__pdu_descr_, *myleaf.body.node.nodes[10]); if (field_opt__part.ispresent() && (field_pn__bit != bs_3 && field_s__bit != bs_3 && field_e__bit != bs_3)) { RAW_enc_tree* temp_leaf; { RAW_enc_tr_pos pr_pos0; pr_pos0.level=myleaf.curr_pos.level+1; int new_pos0[]={0}; pr_pos0.pos=init_new_tree_pos(myleaf.curr_pos,1,new_pos0); temp_leaf = myleaf.get_node(pr_pos0); if(temp_leaf != NULL){ bs_3.RAW_encode(General__Types::BIT1_descr_,*temp_leaf); } else { RAW_enc_tr_pos pr_pos1; pr_pos1.level=myleaf.curr_pos.level+1; int new_pos1[]={1}; pr_pos1.pos=init_new_tree_pos(myleaf.curr_pos,1,new_pos1); temp_leaf = myleaf.get_node(pr_pos1); if(temp_leaf != NULL){ bs_3.RAW_encode(General__Types::BIT1_descr_,*temp_leaf); } else { RAW_enc_tr_pos pr_pos2; pr_pos2.level=myleaf.curr_pos.level+1; int new_pos2[]={2}; pr_pos2.pos=init_new_tree_pos(myleaf.curr_pos,1,new_pos2); temp_leaf = myleaf.get_node(pr_pos2); if(temp_leaf != NULL){ bs_3.RAW_encode(General__Types::BIT1_descr_,*temp_leaf); } else { TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); } free_tree_pos(pr_pos2.pos); } free_tree_pos(pr_pos1.pos); } free_tree_pos(pr_pos0.pos); } } switch (field_gtpc__pdu.get_selection()) { case GTPC__PDUs::ALT_echoRequest: if (field_messageType != os_13) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_13.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_echoResponse: if (field_messageType != os_2) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_2.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_versionNotSupported: if (field_messageType != os_3) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_3.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_createPDPContextRequest: if (field_messageType != os_5) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_5.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_createPDPContextResponse: if (field_messageType != os_6) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_6.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_updatePDPContextRequest: if (field_messageType != os_81) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_81.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_updatePDPContextResponse: if (field_messageType != os_48) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_48.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_deletePDPContextRequest: if (field_messageType != os_7) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_7.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_deletePDPContextResponse: if (field_messageType != os_83) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_83.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_initiatePDPContextActivationRequest: if (field_messageType != os_61) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_61.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_initiatePDPContextActivationResponse: if (field_messageType != os_62) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_62.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_pdu__NotificationRequest: if (field_messageType != os_9) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_9.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_pdu__NotificationResponse: if (field_messageType != os_10) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_10.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_pdu__NotificationRejectRequest: if (field_messageType != os_51) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_51.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_pdu__NotificationRejectResponse: if (field_messageType != os_131) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_131.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_supportedExtensionHeadersNotification: if (field_messageType != os_132) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_132.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSRequest: if (field_messageType != os_133) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_133.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_sendRouteingInformationForGPRSResponse: if (field_messageType != os_11) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_11.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_failureReportRequest: if (field_messageType != os_134) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_134.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_failureReportResponse: if (field_messageType != os_135) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_135.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_noteMS__GPRSPresentRequest: if (field_messageType != os_136) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_136.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_noteMS__GPRSPresentResponse: if (field_messageType != os_137) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_137.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_identificationRequest: if (field_messageType != os_138) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_138.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_identificationResponse: if (field_messageType != os_139) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_139.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_sgsn__ContextRequest: if (field_messageType != os_140) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_140.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_sgsn__ContextResponse: if (field_messageType != os_141) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_141.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_sgsn__ContextAcknowledge: if (field_messageType != os_142) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_142.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_forwardRelocationRequest: if (field_messageType != os_143) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_143.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_forwardRelocationResponse: if (field_messageType != os_144) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_144.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_forwardRelocationComplete: if (field_messageType != os_145) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_145.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_relocationCancelRequest: if (field_messageType != os_146) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_146.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_relocationCancelResponse: if (field_messageType != os_147) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_147.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_forwardSRNSContext: if (field_messageType != os_148) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_148.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_forwardRelocationCompleteAcknowledge: if (field_messageType != os_149) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_149.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_forwardSRNSContextAcknowledge: if (field_messageType != os_150) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_150.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_uERegistrationQueryRequest: if (field_messageType != os_151) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_151.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_uERegistrationQueryResponse: if (field_messageType != os_152) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_152.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_ranInformationRelay: if (field_messageType != os_153) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_153.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSNotificationRequest: if (field_messageType != os_154) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_154.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSNotificationResponse: if (field_messageType != os_155) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_155.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSNotificationRejectRequest: if (field_messageType != os_156) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_156.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSNotificationRejectResponse: if (field_messageType != os_157) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_157.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_createMBMSContextRequest: if (field_messageType != os_158) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_158.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_createMBMSContextResponse: if (field_messageType != os_159) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_159.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_updateMBMSContextRequest: if (field_messageType != os_160) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_160.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_updateMBMSContextResponse: if (field_messageType != os_161) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_161.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_deleteMBMSContextRequest: if (field_messageType != os_162) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_162.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_deleteMBMSContextResponse: if (field_messageType != os_163) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_163.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSRegistrationRequest: if (field_messageType != os_110) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_110.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSRegistrationResponse: if (field_messageType != os_109) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_109.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSDeRegistrationRequest: if (field_messageType != os_111) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_111.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSDeRegistrationResponse: if (field_messageType != os_112) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_112.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSSessionStartRequest: if (field_messageType != os_113) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_113.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSSessionStartResponse: if (field_messageType != os_164) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_164.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSSessionStopRequest: if (field_messageType != os_165) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_165.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSSessionStopResponse: if (field_messageType != os_166) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_166.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSSessionUpdateRequest: if (field_messageType != os_167) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_167.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mBMSSessionUpdateResponse: if (field_messageType != os_168) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_168.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationRequest: if (field_messageType != os_15) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_15.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; case GTPC__PDUs::ALT_mS__InfoChangeNotificationResponse: if (field_messageType != os_65) { RAW_enc_tr_pos pr_pos; pr_pos.level = myleaf.curr_pos.level + 1; int new_pos[] = { 6 }; pr_pos.pos = init_new_tree_pos(myleaf.curr_pos, 1, new_pos); RAW_enc_tree* temp_leaf = myleaf.get_node(pr_pos); if (temp_leaf != NULL) os_65.RAW_encode(General__Types::OCT1_descr_,*temp_leaf); else TTCN_EncDec_ErrorContext::error (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value."); free_tree_pos(pr_pos.pos); } break; default:; } return myleaf.length = encoded_length; } struct PDU__GTPC_template::single_value_struct { BITSTRING_template field_pn__bit; BITSTRING_template field_s__bit; BITSTRING_template field_e__bit; BITSTRING_template field_spare; BITSTRING_template field_pt; BITSTRING_template field_version; OCTETSTRING_template field_messageType; INTEGER_template field_lengthf; OCTETSTRING_template field_teid; GTPC__Header__optional__part_template field_opt__part; GTPC__PDUs_template field_gtpc__pdu; }; void PDU__GTPC_template::set_specific() { if (template_selection != SPECIFIC_VALUE) { template_sel old_selection = template_selection; clean_up(); single_value = new single_value_struct; set_selection(SPECIFIC_VALUE); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) { single_value->field_pn__bit = ANY_VALUE; single_value->field_s__bit = ANY_VALUE; single_value->field_e__bit = ANY_VALUE; single_value->field_spare = ANY_VALUE; single_value->field_pt = ANY_VALUE; single_value->field_version = ANY_VALUE; single_value->field_messageType = ANY_VALUE; single_value->field_lengthf = ANY_VALUE; single_value->field_teid = ANY_VALUE; single_value->field_opt__part = ANY_OR_OMIT; single_value->field_gtpc__pdu = ANY_VALUE; } } } void PDU__GTPC_template::copy_value(const PDU__GTPC& other_value) { single_value = new single_value_struct; if (other_value.pn__bit().is_bound()) { single_value->field_pn__bit = other_value.pn__bit(); } else { single_value->field_pn__bit.clean_up(); } if (other_value.s__bit().is_bound()) { single_value->field_s__bit = other_value.s__bit(); } else { single_value->field_s__bit.clean_up(); } if (other_value.e__bit().is_bound()) { single_value->field_e__bit = other_value.e__bit(); } else { single_value->field_e__bit.clean_up(); } if (other_value.spare().is_bound()) { single_value->field_spare = other_value.spare(); } else { single_value->field_spare.clean_up(); } if (other_value.pt().is_bound()) { single_value->field_pt = other_value.pt(); } else { single_value->field_pt.clean_up(); } if (other_value.version().is_bound()) { single_value->field_version = other_value.version(); } else { single_value->field_version.clean_up(); } if (other_value.messageType().is_bound()) { single_value->field_messageType = other_value.messageType(); } else { single_value->field_messageType.clean_up(); } if (other_value.lengthf().is_bound()) { single_value->field_lengthf = other_value.lengthf(); } else { single_value->field_lengthf.clean_up(); } if (other_value.teid().is_bound()) { single_value->field_teid = other_value.teid(); } else { single_value->field_teid.clean_up(); } if (other_value.opt__part().is_bound()) { if (other_value.opt__part().ispresent()) single_value->field_opt__part = other_value.opt__part()(); else single_value->field_opt__part = OMIT_VALUE; } else { single_value->field_opt__part.clean_up(); } if (other_value.gtpc__pdu().is_bound()) { single_value->field_gtpc__pdu = other_value.gtpc__pdu(); } else { single_value->field_gtpc__pdu.clean_up(); } set_selection(SPECIFIC_VALUE); } void PDU__GTPC_template::copy_template(const PDU__GTPC_template& other_value) { switch (other_value.template_selection) { case SPECIFIC_VALUE: single_value = new single_value_struct; if (UNINITIALIZED_TEMPLATE != other_value.pn__bit().get_selection()) { single_value->field_pn__bit = other_value.pn__bit(); } else { single_value->field_pn__bit.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.s__bit().get_selection()) { single_value->field_s__bit = other_value.s__bit(); } else { single_value->field_s__bit.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.e__bit().get_selection()) { single_value->field_e__bit = other_value.e__bit(); } else { single_value->field_e__bit.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.spare().get_selection()) { single_value->field_spare = other_value.spare(); } else { single_value->field_spare.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.pt().get_selection()) { single_value->field_pt = other_value.pt(); } else { single_value->field_pt.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.version().get_selection()) { single_value->field_version = other_value.version(); } else { single_value->field_version.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.messageType().get_selection()) { single_value->field_messageType = other_value.messageType(); } else { single_value->field_messageType.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.lengthf().get_selection()) { single_value->field_lengthf = other_value.lengthf(); } else { single_value->field_lengthf.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.teid().get_selection()) { single_value->field_teid = other_value.teid(); } else { single_value->field_teid.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.opt__part().get_selection()) { single_value->field_opt__part = other_value.opt__part(); } else { single_value->field_opt__part.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.gtpc__pdu().get_selection()) { single_value->field_gtpc__pdu = other_value.gtpc__pdu(); } else { single_value->field_gtpc__pdu.clean_up(); } case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: value_list.n_values = other_value.value_list.n_values; value_list.list_value = new PDU__GTPC_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]); break; case IMPLICATION_MATCH: implication_.precondition = new PDU__GTPC_template(*other_value.implication_.precondition); implication_.implied_template = new PDU__GTPC_template(*other_value.implication_.implied_template); break; case DYNAMIC_MATCH: dyn_match = other_value.dyn_match; dyn_match->ref_count++; break; default: TTCN_error("Copying an uninitialized/unsupported template of type @GTPC_Types.PDU_GTPC."); break; } set_selection(other_value); } PDU__GTPC_template::PDU__GTPC_template() { } PDU__GTPC_template::PDU__GTPC_template(template_sel other_value) : Base_Template(other_value) { check_single_selection(other_value); } PDU__GTPC_template::PDU__GTPC_template(const PDU__GTPC& other_value) { copy_value(other_value); } PDU__GTPC_template::PDU__GTPC_template(const OPTIONAL& other_value) { switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const PDU__GTPC&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Creating a template of type @GTPC_Types.PDU_GTPC from an unbound optional field."); } } PDU__GTPC_template::PDU__GTPC_template(PDU__GTPC_template* p_precondition, PDU__GTPC_template* p_implied_template) : Base_Template(IMPLICATION_MATCH) { implication_.precondition = p_precondition; implication_.implied_template = p_implied_template; } PDU__GTPC_template::PDU__GTPC_template(Dynamic_Match_Interface* p_dyn_match) : Base_Template(DYNAMIC_MATCH) { dyn_match = new dynmatch_struct; dyn_match->ptr = p_dyn_match; dyn_match->ref_count = 1; } PDU__GTPC_template::PDU__GTPC_template(const PDU__GTPC_template& other_value) : Base_Template() { copy_template(other_value); } PDU__GTPC_template::~PDU__GTPC_template() { clean_up(); } PDU__GTPC_template& PDU__GTPC_template::operator=(template_sel other_value) { check_single_selection(other_value); clean_up(); set_selection(other_value); return *this; } PDU__GTPC_template& PDU__GTPC_template::operator=(const PDU__GTPC& other_value) { clean_up(); copy_value(other_value); return *this; } PDU__GTPC_template& PDU__GTPC_template::operator=(const OPTIONAL& other_value) { clean_up(); switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const PDU__GTPC&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Assignment of an unbound optional field to a template of type @GTPC_Types.PDU_GTPC."); } return *this; } PDU__GTPC_template& PDU__GTPC_template::operator=(const PDU__GTPC_template& other_value) { if (&other_value != this) { clean_up(); copy_template(other_value); } return *this; } boolean PDU__GTPC_template::match(const PDU__GTPC& other_value, boolean legacy) const { if (!other_value.is_bound()) return FALSE; switch (template_selection) { case ANY_VALUE: case ANY_OR_OMIT: return TRUE; case OMIT_VALUE: return FALSE; case SPECIFIC_VALUE: if(!other_value.pn__bit().is_bound()) return FALSE; if(!single_value->field_pn__bit.match(other_value.pn__bit(), legacy))return FALSE; if(!other_value.s__bit().is_bound()) return FALSE; if(!single_value->field_s__bit.match(other_value.s__bit(), legacy))return FALSE; if(!other_value.e__bit().is_bound()) return FALSE; if(!single_value->field_e__bit.match(other_value.e__bit(), legacy))return FALSE; if(!other_value.spare().is_bound()) return FALSE; if(!single_value->field_spare.match(other_value.spare(), legacy))return FALSE; if(!other_value.pt().is_bound()) return FALSE; if(!single_value->field_pt.match(other_value.pt(), legacy))return FALSE; if(!other_value.version().is_bound()) return FALSE; if(!single_value->field_version.match(other_value.version(), legacy))return FALSE; if(!other_value.messageType().is_bound()) return FALSE; if(!single_value->field_messageType.match(other_value.messageType(), legacy))return FALSE; if(!other_value.lengthf().is_bound()) return FALSE; if(!single_value->field_lengthf.match(other_value.lengthf(), legacy))return FALSE; if(!other_value.teid().is_bound()) return FALSE; if(!single_value->field_teid.match(other_value.teid(), legacy))return FALSE; if(!other_value.opt__part().is_bound()) return FALSE; if((other_value.opt__part().ispresent() ? !single_value->field_opt__part.match((const GTPC__Header__optional__part&)other_value.opt__part(), legacy) : !single_value->field_opt__part.match_omit(legacy)))return FALSE; if(!other_value.gtpc__pdu().is_bound()) return FALSE; if(!single_value->field_gtpc__pdu.match(other_value.gtpc__pdu(), legacy))return FALSE; return TRUE; case VALUE_LIST: case COMPLEMENTED_LIST: for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) if (value_list.list_value[list_count].match(other_value, legacy)) return template_selection == VALUE_LIST; return template_selection == COMPLEMENTED_LIST; case CONJUNCTION_MATCH: for (unsigned int i = 0; i < value_list.n_values; i++) { if (!value_list.list_value[i].match(other_value)) { return FALSE; } } return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value); case DYNAMIC_MATCH: return dyn_match->ptr->match(other_value); default: TTCN_error("Matching an uninitialized/unsupported template of type @GTPC_Types.PDU_GTPC."); } return FALSE; } boolean PDU__GTPC_template::is_bound() const { if (template_selection == UNINITIALIZED_TEMPLATE && !is_ifpresent) return FALSE; if (template_selection != SPECIFIC_VALUE) return TRUE; return single_value->field_pn__bit.is_bound() || single_value->field_s__bit.is_bound() || single_value->field_e__bit.is_bound() || single_value->field_spare.is_bound() || single_value->field_pt.is_bound() || single_value->field_version.is_bound() || single_value->field_messageType.is_bound() || single_value->field_lengthf.is_bound() || single_value->field_teid.is_bound() || (single_value->field_opt__part.is_omit() || single_value->field_opt__part.is_bound()) || single_value->field_gtpc__pdu.is_bound(); } boolean PDU__GTPC_template::is_value() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE; return single_value->field_pn__bit.is_value() && single_value->field_s__bit.is_value() && single_value->field_e__bit.is_value() && single_value->field_spare.is_value() && single_value->field_pt.is_value() && single_value->field_version.is_value() && single_value->field_messageType.is_value() && single_value->field_lengthf.is_value() && single_value->field_teid.is_value() && (single_value->field_opt__part.is_omit() || single_value->field_opt__part.is_value()) && single_value->field_gtpc__pdu.is_value(); } void PDU__GTPC_template::clean_up() { switch (template_selection) { case SPECIFIC_VALUE: delete single_value; break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: delete [] value_list.list_value; break; case IMPLICATION_MATCH: delete implication_.precondition; delete implication_.implied_template; break; case DYNAMIC_MATCH: dyn_match->ref_count--; if (dyn_match->ref_count == 0) { delete dyn_match->ptr; delete dyn_match; } break; default: break; } template_selection = UNINITIALIZED_TEMPLATE; } PDU__GTPC PDU__GTPC_template::valueof() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of type @GTPC_Types.PDU_GTPC."); PDU__GTPC ret_val; if (single_value->field_pn__bit.is_bound()) { ret_val.pn__bit() = single_value->field_pn__bit.valueof(); } if (single_value->field_s__bit.is_bound()) { ret_val.s__bit() = single_value->field_s__bit.valueof(); } if (single_value->field_e__bit.is_bound()) { ret_val.e__bit() = single_value->field_e__bit.valueof(); } if (single_value->field_spare.is_bound()) { ret_val.spare() = single_value->field_spare.valueof(); } if (single_value->field_pt.is_bound()) { ret_val.pt() = single_value->field_pt.valueof(); } if (single_value->field_version.is_bound()) { ret_val.version() = single_value->field_version.valueof(); } if (single_value->field_messageType.is_bound()) { ret_val.messageType() = single_value->field_messageType.valueof(); } if (single_value->field_lengthf.is_bound()) { ret_val.lengthf() = single_value->field_lengthf.valueof(); } if (single_value->field_teid.is_bound()) { ret_val.teid() = single_value->field_teid.valueof(); } if (single_value->field_opt__part.is_omit()) ret_val.opt__part() = OMIT_VALUE; else if (single_value->field_opt__part.is_bound()) { ret_val.opt__part() = single_value->field_opt__part.valueof(); } if (single_value->field_gtpc__pdu.is_bound()) { ret_val.gtpc__pdu() = single_value->field_gtpc__pdu.valueof(); } return ret_val; } void PDU__GTPC_template::set_type(template_sel template_type, unsigned int list_length) { if (template_type != VALUE_LIST && template_type != COMPLEMENTED_LIST&& template_type != CONJUNCTION_MATCH) TTCN_error("Setting an invalid list for a template of type @GTPC_Types.PDU_GTPC."); clean_up(); set_selection(template_type); value_list.n_values = list_length; value_list.list_value = new PDU__GTPC_template[list_length]; } PDU__GTPC_template& PDU__GTPC_template::list_item(unsigned int list_index) const { if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST&& template_selection != CONJUNCTION_MATCH) TTCN_error("Accessing a list element of a non-list template of type @GTPC_Types.PDU_GTPC."); if (list_index >= value_list.n_values) TTCN_error("Index overflow in a value list template of type @GTPC_Types.PDU_GTPC."); return value_list.list_value[list_index]; } BITSTRING_template& PDU__GTPC_template::pn__bit() { set_specific(); return single_value->field_pn__bit; } const BITSTRING_template& PDU__GTPC_template::pn__bit() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field pn_bit of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_pn__bit; } BITSTRING_template& PDU__GTPC_template::s__bit() { set_specific(); return single_value->field_s__bit; } const BITSTRING_template& PDU__GTPC_template::s__bit() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field s_bit of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_s__bit; } BITSTRING_template& PDU__GTPC_template::e__bit() { set_specific(); return single_value->field_e__bit; } const BITSTRING_template& PDU__GTPC_template::e__bit() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field e_bit of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_e__bit; } BITSTRING_template& PDU__GTPC_template::spare() { set_specific(); return single_value->field_spare; } const BITSTRING_template& PDU__GTPC_template::spare() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field spare of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_spare; } BITSTRING_template& PDU__GTPC_template::pt() { set_specific(); return single_value->field_pt; } const BITSTRING_template& PDU__GTPC_template::pt() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field pt of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_pt; } BITSTRING_template& PDU__GTPC_template::version() { set_specific(); return single_value->field_version; } const BITSTRING_template& PDU__GTPC_template::version() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field version of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_version; } OCTETSTRING_template& PDU__GTPC_template::messageType() { set_specific(); return single_value->field_messageType; } const OCTETSTRING_template& PDU__GTPC_template::messageType() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field messageType of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_messageType; } INTEGER_template& PDU__GTPC_template::lengthf() { set_specific(); return single_value->field_lengthf; } const INTEGER_template& PDU__GTPC_template::lengthf() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field lengthf of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_lengthf; } OCTETSTRING_template& PDU__GTPC_template::teid() { set_specific(); return single_value->field_teid; } const OCTETSTRING_template& PDU__GTPC_template::teid() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field teid of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_teid; } GTPC__Header__optional__part_template& PDU__GTPC_template::opt__part() { set_specific(); return single_value->field_opt__part; } const GTPC__Header__optional__part_template& PDU__GTPC_template::opt__part() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field opt_part of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_opt__part; } GTPC__PDUs_template& PDU__GTPC_template::gtpc__pdu() { set_specific(); return single_value->field_gtpc__pdu; } const GTPC__PDUs_template& PDU__GTPC_template::gtpc__pdu() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field gtpc_pdu of a non-specific template of type @GTPC_Types.PDU_GTPC."); return single_value->field_gtpc__pdu; } int PDU__GTPC_template::size_of() const { if (is_ifpresent) TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.PDU_GTPC which has an ifpresent attribute."); switch (template_selection) { case SPECIFIC_VALUE: { int ret_val = 10; if (single_value->field_opt__part.is_present()) ret_val++; return ret_val; } case VALUE_LIST: { if (value_list.n_values<1) TTCN_error("Internal error: Performing sizeof() operation on a template of type @GTPC_Types.PDU_GTPC containing an empty list."); int item_size = value_list.list_value[0].size_of(); for (unsigned int l_idx = 1; l_idx < value_list.n_values; l_idx++) { if (value_list.list_value[l_idx].size_of()!=item_size) TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.PDU_GTPC containing a value list with different sizes."); } return item_size; } case OMIT_VALUE: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.PDU_GTPC containing omit value."); case ANY_VALUE: case ANY_OR_OMIT: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.PDU_GTPC containing */? value."); case COMPLEMENTED_LIST: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.PDU_GTPC containing complemented list."); case CONJUNCTION_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.PDU_GTPC containing a conjunction list match."); case IMPLICATION_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.PDU_GTPC containing an implication match."); case DYNAMIC_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.PDU_GTPC containing a dynamic match."); default: TTCN_error("Performing sizeof() operation on an uninitialized/unsupported template of type @GTPC_Types.PDU_GTPC."); } return 0; } void PDU__GTPC_template::log() const { switch (template_selection) { case SPECIFIC_VALUE: TTCN_Logger::log_event_str("{ pn_bit := "); single_value->field_pn__bit.log(); TTCN_Logger::log_event_str(", s_bit := "); single_value->field_s__bit.log(); TTCN_Logger::log_event_str(", e_bit := "); single_value->field_e__bit.log(); TTCN_Logger::log_event_str(", spare := "); single_value->field_spare.log(); TTCN_Logger::log_event_str(", pt := "); single_value->field_pt.log(); TTCN_Logger::log_event_str(", version := "); single_value->field_version.log(); TTCN_Logger::log_event_str(", messageType := "); single_value->field_messageType.log(); TTCN_Logger::log_event_str(", lengthf := "); single_value->field_lengthf.log(); TTCN_Logger::log_event_str(", teid := "); single_value->field_teid.log(); TTCN_Logger::log_event_str(", opt_part := "); single_value->field_opt__part.log(); TTCN_Logger::log_event_str(", gtpc_pdu := "); single_value->field_gtpc__pdu.log(); TTCN_Logger::log_event_str(" }"); break; case COMPLEMENTED_LIST: TTCN_Logger::log_event_str("complement"); case CONJUNCTION_MATCH: if (template_selection == CONJUNCTION_MATCH) { TTCN_Logger::log_event_str("conjunct"); } case VALUE_LIST: TTCN_Logger::log_char('('); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) { if (list_count > 0) TTCN_Logger::log_event_str(", "); value_list.list_value[list_count].log(); } TTCN_Logger::log_char(')'); break; case IMPLICATION_MATCH: implication_.precondition->log(); TTCN_Logger::log_event_str(" implies "); implication_.implied_template->log(); break; case DYNAMIC_MATCH: TTCN_Logger::log_event_str("@dynamic template"); break; default: log_generic(); } log_ifpresent(); } void PDU__GTPC_template::log_match(const PDU__GTPC& match_value, boolean legacy) const { if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ if(match(match_value, legacy)){ TTCN_Logger::print_logmatch_buffer(); TTCN_Logger::log_event_str(" matched"); } else{ if (template_selection == SPECIFIC_VALUE) { size_t previous_size = TTCN_Logger::get_logmatch_buffer_len(); if(!single_value->field_pn__bit.match(match_value.pn__bit(), legacy)){ TTCN_Logger::log_logmatch_info(".pn_bit"); single_value->field_pn__bit.log_match(match_value.pn__bit(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_s__bit.match(match_value.s__bit(), legacy)){ TTCN_Logger::log_logmatch_info(".s_bit"); single_value->field_s__bit.log_match(match_value.s__bit(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_e__bit.match(match_value.e__bit(), legacy)){ TTCN_Logger::log_logmatch_info(".e_bit"); single_value->field_e__bit.log_match(match_value.e__bit(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_spare.match(match_value.spare(), legacy)){ TTCN_Logger::log_logmatch_info(".spare"); single_value->field_spare.log_match(match_value.spare(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_pt.match(match_value.pt(), legacy)){ TTCN_Logger::log_logmatch_info(".pt"); single_value->field_pt.log_match(match_value.pt(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_version.match(match_value.version(), legacy)){ TTCN_Logger::log_logmatch_info(".version"); single_value->field_version.log_match(match_value.version(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_messageType.match(match_value.messageType(), legacy)){ TTCN_Logger::log_logmatch_info(".messageType"); single_value->field_messageType.log_match(match_value.messageType(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_lengthf.match(match_value.lengthf(), legacy)){ TTCN_Logger::log_logmatch_info(".lengthf"); single_value->field_lengthf.log_match(match_value.lengthf(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_teid.match(match_value.teid(), legacy)){ TTCN_Logger::log_logmatch_info(".teid"); single_value->field_teid.log_match(match_value.teid(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if (match_value.opt__part().ispresent()){ if(!single_value->field_opt__part.match(match_value.opt__part(), legacy)){ TTCN_Logger::log_logmatch_info(".opt_part"); single_value->field_opt__part.log_match(match_value.opt__part(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } else { if (!single_value->field_opt__part.match_omit(legacy)){ TTCN_Logger::log_logmatch_info(".opt_part := omit with "); TTCN_Logger::print_logmatch_buffer(); single_value->field_opt__part.log(); TTCN_Logger::log_event_str(" unmatched"); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } if(!single_value->field_gtpc__pdu.match(match_value.gtpc__pdu(), legacy)){ TTCN_Logger::log_logmatch_info(".gtpc_pdu"); single_value->field_gtpc__pdu.log_match(match_value.gtpc__pdu(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } }else { TTCN_Logger::print_logmatch_buffer(); match_value.log(); TTCN_Logger::log_event_str(" with "); log(); TTCN_Logger::log_event_str(" unmatched"); } } return; } if (template_selection == SPECIFIC_VALUE) { TTCN_Logger::log_event_str("{ pn_bit := "); single_value->field_pn__bit.log_match(match_value.pn__bit(), legacy); TTCN_Logger::log_event_str(", s_bit := "); single_value->field_s__bit.log_match(match_value.s__bit(), legacy); TTCN_Logger::log_event_str(", e_bit := "); single_value->field_e__bit.log_match(match_value.e__bit(), legacy); TTCN_Logger::log_event_str(", spare := "); single_value->field_spare.log_match(match_value.spare(), legacy); TTCN_Logger::log_event_str(", pt := "); single_value->field_pt.log_match(match_value.pt(), legacy); TTCN_Logger::log_event_str(", version := "); single_value->field_version.log_match(match_value.version(), legacy); TTCN_Logger::log_event_str(", messageType := "); single_value->field_messageType.log_match(match_value.messageType(), legacy); TTCN_Logger::log_event_str(", lengthf := "); single_value->field_lengthf.log_match(match_value.lengthf(), legacy); TTCN_Logger::log_event_str(", teid := "); single_value->field_teid.log_match(match_value.teid(), legacy); TTCN_Logger::log_event_str(", opt_part := "); if (match_value.opt__part().ispresent()) { single_value->field_opt__part.log_match(match_value.opt__part(), legacy); } else { TTCN_Logger::log_event_str("omit with "); single_value->field_opt__part.log(); if (single_value->field_opt__part.match_omit(legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } TTCN_Logger::log_event_str(", gtpc_pdu := "); single_value->field_gtpc__pdu.log_match(match_value.gtpc__pdu(), legacy); TTCN_Logger::log_event_str(" }"); } else { match_value.log(); TTCN_Logger::log_event_str(" with "); log(); if (match(match_value, legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } } void PDU__GTPC_template::encode_text(Text_Buf& text_buf) const { encode_text_base(text_buf); switch (template_selection) { case SPECIFIC_VALUE: single_value->field_pn__bit.encode_text(text_buf); single_value->field_s__bit.encode_text(text_buf); single_value->field_e__bit.encode_text(text_buf); single_value->field_spare.encode_text(text_buf); single_value->field_pt.encode_text(text_buf); single_value->field_version.encode_text(text_buf); single_value->field_messageType.encode_text(text_buf); single_value->field_lengthf.encode_text(text_buf); single_value->field_teid.encode_text(text_buf); single_value->field_opt__part.encode_text(text_buf); single_value->field_gtpc__pdu.encode_text(text_buf); case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: text_buf.push_int(value_list.n_values); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].encode_text(text_buf); break; default: TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of type @GTPC_Types.PDU_GTPC."); } } void PDU__GTPC_template::decode_text(Text_Buf& text_buf) { clean_up(); decode_text_base(text_buf); switch (template_selection) { case SPECIFIC_VALUE: single_value = new single_value_struct; single_value->field_pn__bit.decode_text(text_buf); single_value->field_s__bit.decode_text(text_buf); single_value->field_e__bit.decode_text(text_buf); single_value->field_spare.decode_text(text_buf); single_value->field_pt.decode_text(text_buf); single_value->field_version.decode_text(text_buf); single_value->field_messageType.decode_text(text_buf); single_value->field_lengthf.decode_text(text_buf); single_value->field_teid.decode_text(text_buf); single_value->field_opt__part.decode_text(text_buf); single_value->field_gtpc__pdu.decode_text(text_buf); case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: value_list.n_values = text_buf.pull_int().get_val(); value_list.list_value = new PDU__GTPC_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].decode_text(text_buf); break; default: TTCN_error("Text decoder: An unknown/unsupported selection was received in a template of type @GTPC_Types.PDU_GTPC."); } } void PDU__GTPC_template::set_param(Module_Param& param) { param.basic_check(Module_Param::BC_TEMPLATE, "record template"); switch (param.get_type()) { case Module_Param::MP_Omit: *this = OMIT_VALUE; break; case Module_Param::MP_Any: *this = ANY_VALUE; break; case Module_Param::MP_AnyOrNone: *this = ANY_OR_OMIT; break; case Module_Param::MP_List_Template: case Module_Param::MP_ComplementList_Template: case Module_Param::MP_ConjunctList_Template: { PDU__GTPC_template new_temp; new_temp.set_type(param.get_type()==Module_Param::MP_List_Template ? VALUE_LIST : (param.get_type() == Module_Param::MP_ConjunctList_Template ? CONJUNCTION_MATCH : COMPLEMENTED_LIST), param.get_size()); for (size_t p_i=0; p_i0 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) pn__bit().set_param(*param.get_elem(0)); if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) s__bit().set_param(*param.get_elem(1)); if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) e__bit().set_param(*param.get_elem(2)); if (param.get_size()>3 && param.get_elem(3)->get_type()!=Module_Param::MP_NotUsed) spare().set_param(*param.get_elem(3)); if (param.get_size()>4 && param.get_elem(4)->get_type()!=Module_Param::MP_NotUsed) pt().set_param(*param.get_elem(4)); if (param.get_size()>5 && param.get_elem(5)->get_type()!=Module_Param::MP_NotUsed) version().set_param(*param.get_elem(5)); if (param.get_size()>6 && param.get_elem(6)->get_type()!=Module_Param::MP_NotUsed) messageType().set_param(*param.get_elem(6)); if (param.get_size()>7 && param.get_elem(7)->get_type()!=Module_Param::MP_NotUsed) lengthf().set_param(*param.get_elem(7)); if (param.get_size()>8 && param.get_elem(8)->get_type()!=Module_Param::MP_NotUsed) teid().set_param(*param.get_elem(8)); if (param.get_size()>9 && param.get_elem(9)->get_type()!=Module_Param::MP_NotUsed) opt__part().set_param(*param.get_elem(9)); if (param.get_size()>10 && param.get_elem(10)->get_type()!=Module_Param::MP_NotUsed) gtpc__pdu().set_param(*param.get_elem(10)); break; case Module_Param::MP_Assignment_List: { Vector value_used(param.get_size()); value_used.resize(param.get_size(), FALSE); for (size_t val_idx=0; val_idxget_id()->get_name(), "pn_bit")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { pn__bit().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "s_bit")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { s__bit().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "e_bit")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { e__bit().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "spare")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { spare().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "pt")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { pt().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "version")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { version().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "messageType")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { messageType().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "lengthf")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { lengthf().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "teid")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { teid().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "opt_part")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { opt__part().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "gtpc_pdu")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { gtpc__pdu().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxerror("Non existent field name in type @GTPC_Types.PDU_GTPC: %s", curr_param->get_id()->get_name()); break; } } break; case Module_Param::MP_Implication_Template: { PDU__GTPC_template* precondition = new PDU__GTPC_template; precondition->set_param(*param.get_elem(0)); PDU__GTPC_template* implied_template = new PDU__GTPC_template; implied_template->set_param(*param.get_elem(1)); *this = PDU__GTPC_template(precondition, implied_template); } break; default: param.type_error("record template", "@GTPC_Types.PDU_GTPC"); } is_ifpresent = param.get_ifpresent(); } void PDU__GTPC_template::check_restriction(template_res t_res, const char* t_name, boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return; switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) { case TR_OMIT: if (template_selection==OMIT_VALUE) return; case TR_VALUE: if (template_selection!=SPECIFIC_VALUE || is_ifpresent) break; single_value->field_pn__bit.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); single_value->field_s__bit.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); single_value->field_e__bit.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); single_value->field_spare.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); single_value->field_pt.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); single_value->field_version.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); single_value->field_messageType.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); single_value->field_lengthf.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); single_value->field_teid.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); single_value->field_opt__part.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); single_value->field_gtpc__pdu.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.PDU_GTPC"); return; case TR_PRESENT: if (!match_omit(legacy)) return; break; default: return; } TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@GTPC_Types.PDU_GTPC"); } boolean PDU__GTPC_template::is_present(boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE; return !match_omit(legacy); } boolean PDU__GTPC_template::match_omit(boolean legacy) const { if (is_ifpresent) return TRUE; switch (template_selection) { case OMIT_VALUE: case ANY_OR_OMIT: return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match_omit() || implication_.implied_template->match_omit(); case VALUE_LIST: case COMPLEMENTED_LIST: if (legacy) { for (unsigned int l_idx=0; l_idx& par_gTPC__extensionHeader__List) : field_sequenceNumber(par_sequenceNumber), field_npduNumber(par_npduNumber), field_nextExtHeader(par_nextExtHeader), field_gTPC__extensionHeader__List(par_gTPC__extensionHeader__List) { } GTPC__Header__optional__part::GTPC__Header__optional__part(const GTPC__Header__optional__part& other_value) { if(!other_value.is_bound()) TTCN_error("Copying an unbound value of type @GTPC_Types.GTPC_Header_optional_part."); if (other_value.sequenceNumber().is_bound()) field_sequenceNumber = other_value.sequenceNumber(); else field_sequenceNumber.clean_up(); if (other_value.npduNumber().is_bound()) field_npduNumber = other_value.npduNumber(); else field_npduNumber.clean_up(); if (other_value.nextExtHeader().is_bound()) field_nextExtHeader = other_value.nextExtHeader(); else field_nextExtHeader.clean_up(); if (other_value.gTPC__extensionHeader__List().is_bound()) field_gTPC__extensionHeader__List = other_value.gTPC__extensionHeader__List(); else field_gTPC__extensionHeader__List.clean_up(); } void GTPC__Header__optional__part::clean_up() { field_sequenceNumber.clean_up(); field_npduNumber.clean_up(); field_nextExtHeader.clean_up(); field_gTPC__extensionHeader__List.clean_up(); } const TTCN_Typedescriptor_t* GTPC__Header__optional__part::get_descriptor() const { return >PC__Header__optional__part_descr_; } GTPC__Header__optional__part& GTPC__Header__optional__part::operator=(const GTPC__Header__optional__part& other_value) { if (this != &other_value) { if(!other_value.is_bound()) TTCN_error("Assignment of an unbound value of type @GTPC_Types.GTPC_Header_optional_part."); if (other_value.sequenceNumber().is_bound()) field_sequenceNumber = other_value.sequenceNumber(); else field_sequenceNumber.clean_up(); if (other_value.npduNumber().is_bound()) field_npduNumber = other_value.npduNumber(); else field_npduNumber.clean_up(); if (other_value.nextExtHeader().is_bound()) field_nextExtHeader = other_value.nextExtHeader(); else field_nextExtHeader.clean_up(); if (other_value.gTPC__extensionHeader__List().is_bound()) field_gTPC__extensionHeader__List = other_value.gTPC__extensionHeader__List(); else field_gTPC__extensionHeader__List.clean_up(); } return *this; } boolean GTPC__Header__optional__part::operator==(const GTPC__Header__optional__part& other_value) const { return field_sequenceNumber==other_value.field_sequenceNumber && field_npduNumber==other_value.field_npduNumber && field_nextExtHeader==other_value.field_nextExtHeader && field_gTPC__extensionHeader__List==other_value.field_gTPC__extensionHeader__List; } boolean GTPC__Header__optional__part::is_bound() const { return (field_sequenceNumber.is_bound()) || (field_npduNumber.is_bound()) || (field_nextExtHeader.is_bound()) || (OPTIONAL_OMIT == field_gTPC__extensionHeader__List.get_selection() || field_gTPC__extensionHeader__List.is_bound()); } boolean GTPC__Header__optional__part::is_value() const { return field_sequenceNumber.is_value() && field_npduNumber.is_value() && field_nextExtHeader.is_value() && (OPTIONAL_OMIT == field_gTPC__extensionHeader__List.get_selection() || field_gTPC__extensionHeader__List.is_value()); } int GTPC__Header__optional__part::size_of() const { int ret_val = 3; if (field_gTPC__extensionHeader__List.ispresent()) ret_val++; return ret_val; } void GTPC__Header__optional__part::log() const { if (!is_bound()) { TTCN_Logger::log_event_unbound(); return; } TTCN_Logger::log_event_str("{ sequenceNumber := "); field_sequenceNumber.log(); TTCN_Logger::log_event_str(", npduNumber := "); field_npduNumber.log(); TTCN_Logger::log_event_str(", nextExtHeader := "); field_nextExtHeader.log(); TTCN_Logger::log_event_str(", gTPC_extensionHeader_List := "); field_gTPC__extensionHeader__List.log(); TTCN_Logger::log_event_str(" }"); } void GTPC__Header__optional__part::set_implicit_omit() { if (sequenceNumber().is_bound()) sequenceNumber().set_implicit_omit(); if (npduNumber().is_bound()) npduNumber().set_implicit_omit(); if (nextExtHeader().is_bound()) nextExtHeader().set_implicit_omit(); if (!gTPC__extensionHeader__List().is_bound()) gTPC__extensionHeader__List() = OMIT_VALUE; else gTPC__extensionHeader__List().set_implicit_omit(); } void GTPC__Header__optional__part::set_param(Module_Param& param) { param.basic_check(Module_Param::BC_VALUE, "record value"); switch (param.get_type()) { case Module_Param::MP_Value_List: if (40 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) sequenceNumber().set_param(*param.get_elem(0)); if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) npduNumber().set_param(*param.get_elem(1)); if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) nextExtHeader().set_param(*param.get_elem(2)); if (param.get_size()>3 && param.get_elem(3)->get_type()!=Module_Param::MP_NotUsed) gTPC__extensionHeader__List().set_param(*param.get_elem(3)); break; case Module_Param::MP_Assignment_List: { Vector value_used(param.get_size()); value_used.resize(param.get_size(), FALSE); for (size_t val_idx=0; val_idxget_id()->get_name(), "sequenceNumber")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { sequenceNumber().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "npduNumber")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { npduNumber().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "nextExtHeader")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { nextExtHeader().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "gTPC_extensionHeader_List")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { gTPC__extensionHeader__List().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxerror("Non existent field name in type @GTPC_Types.GTPC_Header_optional_part: %s", curr_param->get_id()->get_name()); break; } } break; default: param.type_error("record value", "@GTPC_Types.GTPC_Header_optional_part"); } } void GTPC__Header__optional__part::encode_text(Text_Buf& text_buf) const { field_sequenceNumber.encode_text(text_buf); field_npduNumber.encode_text(text_buf); field_nextExtHeader.encode_text(text_buf); field_gTPC__extensionHeader__List.encode_text(text_buf); } void GTPC__Header__optional__part::decode_text(Text_Buf& text_buf) { field_sequenceNumber.decode_text(text_buf); field_npduNumber.decode_text(text_buf); field_nextExtHeader.decode_text(text_buf); field_gTPC__extensionHeader__List.decode_text(text_buf); } void GTPC__Header__optional__part::encode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) const { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-encoding type '%s': ", p_td.name); unsigned BER_coding=va_arg(pvar, unsigned); BER_encode_chk_coding(BER_coding); ASN_BER_TLV_t *tlv=BER_encode_TLV(p_td, BER_coding); tlv->put_in_buffer(p_buf); ASN_BER_TLV_t::destruct(tlv); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-encoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); RAW_enc_tr_pos rp; rp.level=0; rp.pos=NULL; RAW_enc_tree root(FALSE, NULL, &rp, 1, p_td.raw); RAW_encode(p_td, root); root.put_to_buf(p_buf); break;} case TTCN_EncDec::CT_TEXT: { TTCN_EncDec_ErrorContext ec("While TEXT-encoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); TEXT_encode(p_td,p_buf); break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-encoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XER_encode(*(p_td.xer),p_buf, XER_coding, 0, 0, 0); p_buf.put_c('\n'); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-encoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok(va_arg(pvar, int) != 0); JSON_encode(p_td, tok, FALSE); p_buf.put_s(tok.get_buffer_length(), (const unsigned char*)tok.get_buffer()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-encoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_encode(p_td, p_buf); break;} default: TTCN_error("Unknown coding method requested to encode type '%s'", p_td.name); } va_end(pvar); } void GTPC__Header__optional__part::decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-decoding type '%s': ", p_td.name); unsigned L_form=va_arg(pvar, unsigned); ASN_BER_TLV_t tlv; BER_decode_str2TLV(p_buf, tlv, L_form); BER_decode_TLV(p_td, tlv, L_form); if(tlv.isComplete) p_buf.increase_pos(tlv.get_len()); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-decoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); raw_order_t r_order; switch(p_td.raw->top_bit_order) { case TOP_BIT_LEFT: r_order=ORDER_LSB; break; case TOP_BIT_RIGHT: default: r_order=ORDER_MSB; } int rawr = RAW_decode(p_td, p_buf, p_buf.get_len()*8, r_order); if(rawr<0) switch (-rawr) { case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: ec.error((TTCN_EncDec::error_type_t)-rawr, "Can not decode type '%s', because incomplete message was received", p_td.name); break; case 1: default: ec.error(TTCN_EncDec::ET_INVAL_MSG, "Can not decode type '%s', because invalid message was received", p_td.name); break; } break;} case TTCN_EncDec::CT_TEXT: { Limit_Token_List limit; TTCN_EncDec_ErrorContext ec("While TEXT-decoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); const unsigned char *b_data=p_buf.get_data(); int null_added=0; if(b_data[p_buf.get_len()-1]!='\0'){ null_added=1; p_buf.set_pos(p_buf.get_len()); p_buf.put_zero(8,ORDER_LSB); p_buf.rewind(); } if(TEXT_decode(p_td,p_buf,limit)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); if(null_added){ size_t actpos=p_buf.get_pos(); p_buf.set_pos(p_buf.get_len()-1); p_buf.cut_end(); p_buf.set_pos(actpos); } break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-decoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XmlReaderWrap reader(p_buf); for (int rd_ok=reader.Read(); rd_ok==1; rd_ok=reader.Read()) { if (reader.NodeType() == XML_READER_TYPE_ELEMENT) break; } XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL, XER_NONE, 0); size_t bytes = reader.ByteConsumed(); p_buf.set_pos(bytes); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-decoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok((const char*)p_buf.get_data(), p_buf.get_len()); if(JSON_decode(p_td, tok, FALSE, FALSE)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); p_buf.set_pos(tok.get_buf_pos()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-decoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_struct p_oer; OER_decode(p_td, p_buf, p_oer); break;} default: TTCN_error("Unknown coding method requested to decode type '%s'", p_td.name); } va_end(pvar); } int GTPC__Header__optional__part::RAW_decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int limit, raw_order_t top_bit_ord, boolean no_err, int, boolean, const RAW_Force_Omit* force_omit) { (void)no_err; int prepaddlength=p_buf.increase_pos_padd(p_td.raw->prepadding); limit-=prepaddlength; size_t last_decoded_pos = p_buf.get_pos_bit(); int decoded_length = 0; int decoded_field_length = 0; raw_order_t local_top_order; if(p_td.raw->top_bit_order==TOP_BIT_INHERITED)local_top_order=top_bit_ord; else if(p_td.raw->top_bit_order==TOP_BIT_RIGHT)local_top_order=ORDER_MSB; else local_top_order=ORDER_LSB; RAW_Force_Omit field_0_force_omit(0, force_omit, General__Types::OCT2_descr_.raw->forceomit); decoded_field_length = field_sequenceNumber.RAW_decode(General__Types::OCT2_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_0_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); RAW_Force_Omit field_1_force_omit(1, force_omit, General__Types::OCT1_descr_.raw->forceomit); decoded_field_length = field_npduNumber.RAW_decode(General__Types::OCT1_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_1_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); RAW_Force_Omit field_2_force_omit(2, force_omit, General__Types::OCT1_descr_.raw->forceomit); decoded_field_length = field_nextExtHeader.RAW_decode(General__Types::OCT1_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_2_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); if (limit > 0){ if (force_omit != NULL && (*force_omit)(3)) { field_gTPC__extensionHeader__List = OMIT_VALUE; } else { size_t fl_start_pos = p_buf.get_pos_bit(); RAW_Force_Omit field_3_force_omit(3, force_omit, GTPC__ExtensionHeader__List_descr_.raw->forceomit); decoded_field_length = field_gTPC__extensionHeader__List().RAW_decode(GTPC__ExtensionHeader__List_descr_, p_buf, limit, local_top_order, TRUE, -1, TRUE, &field_3_force_omit); if (decoded_field_length < 1) { field_gTPC__extensionHeader__List = OMIT_VALUE; p_buf.set_pos_bit(fl_start_pos); } else { decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); } } } else field_gTPC__extensionHeader__List=OMIT_VALUE; p_buf.set_pos_bit(last_decoded_pos); return decoded_length+prepaddlength+p_buf.increase_pos_padd(p_td.raw->padding); } int GTPC__Header__optional__part::RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree& myleaf) const { if (!is_bound()) TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_UNBOUND, "Encoding an unbound value."); int encoded_length = 0; myleaf.isleaf = FALSE; myleaf.body.node.num_of_nodes = 4; myleaf.body.node.nodes = init_nodes_of_enc_tree(4); myleaf.body.node.nodes[0] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 0, General__Types::OCT2_descr_.raw); myleaf.body.node.nodes[1] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 1, General__Types::OCT1_descr_.raw); myleaf.body.node.nodes[2] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 2, General__Types::OCT1_descr_.raw); if (field_gTPC__extensionHeader__List.ispresent()) { myleaf.body.node.nodes[3] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 3, GTPC__ExtensionHeader__List_descr_.raw); } else myleaf.body.node.nodes[3] = NULL; encoded_length += field_sequenceNumber.RAW_encode(General__Types::OCT2_descr_, *myleaf.body.node.nodes[0]); encoded_length += field_npduNumber.RAW_encode(General__Types::OCT1_descr_, *myleaf.body.node.nodes[1]); encoded_length += field_nextExtHeader.RAW_encode(General__Types::OCT1_descr_, *myleaf.body.node.nodes[2]); if (field_gTPC__extensionHeader__List.ispresent()) { encoded_length += field_gTPC__extensionHeader__List().RAW_encode(GTPC__ExtensionHeader__List_descr_, *myleaf.body.node.nodes[3]); } return myleaf.length = encoded_length; } struct GTPC__Header__optional__part_template::single_value_struct { OCTETSTRING_template field_sequenceNumber; OCTETSTRING_template field_npduNumber; OCTETSTRING_template field_nextExtHeader; GTPC__ExtensionHeader__List_template field_gTPC__extensionHeader__List; }; void GTPC__Header__optional__part_template::set_specific() { if (template_selection != SPECIFIC_VALUE) { template_sel old_selection = template_selection; clean_up(); single_value = new single_value_struct; set_selection(SPECIFIC_VALUE); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) { single_value->field_sequenceNumber = ANY_VALUE; single_value->field_npduNumber = ANY_VALUE; single_value->field_nextExtHeader = ANY_VALUE; single_value->field_gTPC__extensionHeader__List = ANY_OR_OMIT; } } } void GTPC__Header__optional__part_template::copy_value(const GTPC__Header__optional__part& other_value) { single_value = new single_value_struct; if (other_value.sequenceNumber().is_bound()) { single_value->field_sequenceNumber = other_value.sequenceNumber(); } else { single_value->field_sequenceNumber.clean_up(); } if (other_value.npduNumber().is_bound()) { single_value->field_npduNumber = other_value.npduNumber(); } else { single_value->field_npduNumber.clean_up(); } if (other_value.nextExtHeader().is_bound()) { single_value->field_nextExtHeader = other_value.nextExtHeader(); } else { single_value->field_nextExtHeader.clean_up(); } if (other_value.gTPC__extensionHeader__List().is_bound()) { if (other_value.gTPC__extensionHeader__List().ispresent()) single_value->field_gTPC__extensionHeader__List = other_value.gTPC__extensionHeader__List()(); else single_value->field_gTPC__extensionHeader__List = OMIT_VALUE; } else { single_value->field_gTPC__extensionHeader__List.clean_up(); } set_selection(SPECIFIC_VALUE); } void GTPC__Header__optional__part_template::copy_template(const GTPC__Header__optional__part_template& other_value) { switch (other_value.template_selection) { case SPECIFIC_VALUE: single_value = new single_value_struct; if (UNINITIALIZED_TEMPLATE != other_value.sequenceNumber().get_selection()) { single_value->field_sequenceNumber = other_value.sequenceNumber(); } else { single_value->field_sequenceNumber.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.npduNumber().get_selection()) { single_value->field_npduNumber = other_value.npduNumber(); } else { single_value->field_npduNumber.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.nextExtHeader().get_selection()) { single_value->field_nextExtHeader = other_value.nextExtHeader(); } else { single_value->field_nextExtHeader.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.gTPC__extensionHeader__List().get_selection()) { single_value->field_gTPC__extensionHeader__List = other_value.gTPC__extensionHeader__List(); } else { single_value->field_gTPC__extensionHeader__List.clean_up(); } case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: value_list.n_values = other_value.value_list.n_values; value_list.list_value = new GTPC__Header__optional__part_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]); break; case IMPLICATION_MATCH: implication_.precondition = new GTPC__Header__optional__part_template(*other_value.implication_.precondition); implication_.implied_template = new GTPC__Header__optional__part_template(*other_value.implication_.implied_template); break; case DYNAMIC_MATCH: dyn_match = other_value.dyn_match; dyn_match->ref_count++; break; default: TTCN_error("Copying an uninitialized/unsupported template of type @GTPC_Types.GTPC_Header_optional_part."); break; } set_selection(other_value); } GTPC__Header__optional__part_template::GTPC__Header__optional__part_template() { } GTPC__Header__optional__part_template::GTPC__Header__optional__part_template(template_sel other_value) : Base_Template(other_value) { check_single_selection(other_value); } GTPC__Header__optional__part_template::GTPC__Header__optional__part_template(const GTPC__Header__optional__part& other_value) { copy_value(other_value); } GTPC__Header__optional__part_template::GTPC__Header__optional__part_template(const OPTIONAL& other_value) { switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const GTPC__Header__optional__part&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Creating a template of type @GTPC_Types.GTPC_Header_optional_part from an unbound optional field."); } } GTPC__Header__optional__part_template::GTPC__Header__optional__part_template(GTPC__Header__optional__part_template* p_precondition, GTPC__Header__optional__part_template* p_implied_template) : Base_Template(IMPLICATION_MATCH) { implication_.precondition = p_precondition; implication_.implied_template = p_implied_template; } GTPC__Header__optional__part_template::GTPC__Header__optional__part_template(Dynamic_Match_Interface* p_dyn_match) : Base_Template(DYNAMIC_MATCH) { dyn_match = new dynmatch_struct; dyn_match->ptr = p_dyn_match; dyn_match->ref_count = 1; } GTPC__Header__optional__part_template::GTPC__Header__optional__part_template(const GTPC__Header__optional__part_template& other_value) : Base_Template() { copy_template(other_value); } GTPC__Header__optional__part_template::~GTPC__Header__optional__part_template() { clean_up(); } GTPC__Header__optional__part_template& GTPC__Header__optional__part_template::operator=(template_sel other_value) { check_single_selection(other_value); clean_up(); set_selection(other_value); return *this; } GTPC__Header__optional__part_template& GTPC__Header__optional__part_template::operator=(const GTPC__Header__optional__part& other_value) { clean_up(); copy_value(other_value); return *this; } GTPC__Header__optional__part_template& GTPC__Header__optional__part_template::operator=(const OPTIONAL& other_value) { clean_up(); switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const GTPC__Header__optional__part&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Assignment of an unbound optional field to a template of type @GTPC_Types.GTPC_Header_optional_part."); } return *this; } GTPC__Header__optional__part_template& GTPC__Header__optional__part_template::operator=(const GTPC__Header__optional__part_template& other_value) { if (&other_value != this) { clean_up(); copy_template(other_value); } return *this; } boolean GTPC__Header__optional__part_template::match(const GTPC__Header__optional__part& other_value, boolean legacy) const { if (!other_value.is_bound()) return FALSE; switch (template_selection) { case ANY_VALUE: case ANY_OR_OMIT: return TRUE; case OMIT_VALUE: return FALSE; case SPECIFIC_VALUE: if(!other_value.sequenceNumber().is_bound()) return FALSE; if(!single_value->field_sequenceNumber.match(other_value.sequenceNumber(), legacy))return FALSE; if(!other_value.npduNumber().is_bound()) return FALSE; if(!single_value->field_npduNumber.match(other_value.npduNumber(), legacy))return FALSE; if(!other_value.nextExtHeader().is_bound()) return FALSE; if(!single_value->field_nextExtHeader.match(other_value.nextExtHeader(), legacy))return FALSE; if(!other_value.gTPC__extensionHeader__List().is_bound()) return FALSE; if((other_value.gTPC__extensionHeader__List().ispresent() ? !single_value->field_gTPC__extensionHeader__List.match((const GTPC__ExtensionHeader__List&)other_value.gTPC__extensionHeader__List(), legacy) : !single_value->field_gTPC__extensionHeader__List.match_omit(legacy)))return FALSE; return TRUE; case VALUE_LIST: case COMPLEMENTED_LIST: for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) if (value_list.list_value[list_count].match(other_value, legacy)) return template_selection == VALUE_LIST; return template_selection == COMPLEMENTED_LIST; case CONJUNCTION_MATCH: for (unsigned int i = 0; i < value_list.n_values; i++) { if (!value_list.list_value[i].match(other_value)) { return FALSE; } } return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value); case DYNAMIC_MATCH: return dyn_match->ptr->match(other_value); default: TTCN_error("Matching an uninitialized/unsupported template of type @GTPC_Types.GTPC_Header_optional_part."); } return FALSE; } boolean GTPC__Header__optional__part_template::is_bound() const { if (template_selection == UNINITIALIZED_TEMPLATE && !is_ifpresent) return FALSE; if (template_selection != SPECIFIC_VALUE) return TRUE; return single_value->field_sequenceNumber.is_bound() || single_value->field_npduNumber.is_bound() || single_value->field_nextExtHeader.is_bound() || (single_value->field_gTPC__extensionHeader__List.is_omit() || single_value->field_gTPC__extensionHeader__List.is_bound()); } boolean GTPC__Header__optional__part_template::is_value() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE; return single_value->field_sequenceNumber.is_value() && single_value->field_npduNumber.is_value() && single_value->field_nextExtHeader.is_value() && (single_value->field_gTPC__extensionHeader__List.is_omit() || single_value->field_gTPC__extensionHeader__List.is_value()); } void GTPC__Header__optional__part_template::clean_up() { switch (template_selection) { case SPECIFIC_VALUE: delete single_value; break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: delete [] value_list.list_value; break; case IMPLICATION_MATCH: delete implication_.precondition; delete implication_.implied_template; break; case DYNAMIC_MATCH: dyn_match->ref_count--; if (dyn_match->ref_count == 0) { delete dyn_match->ptr; delete dyn_match; } break; default: break; } template_selection = UNINITIALIZED_TEMPLATE; } GTPC__Header__optional__part GTPC__Header__optional__part_template::valueof() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of type @GTPC_Types.GTPC_Header_optional_part."); GTPC__Header__optional__part ret_val; if (single_value->field_sequenceNumber.is_bound()) { ret_val.sequenceNumber() = single_value->field_sequenceNumber.valueof(); } if (single_value->field_npduNumber.is_bound()) { ret_val.npduNumber() = single_value->field_npduNumber.valueof(); } if (single_value->field_nextExtHeader.is_bound()) { ret_val.nextExtHeader() = single_value->field_nextExtHeader.valueof(); } if (single_value->field_gTPC__extensionHeader__List.is_omit()) ret_val.gTPC__extensionHeader__List() = OMIT_VALUE; else if (single_value->field_gTPC__extensionHeader__List.is_bound()) { ret_val.gTPC__extensionHeader__List() = single_value->field_gTPC__extensionHeader__List.valueof(); } return ret_val; } void GTPC__Header__optional__part_template::set_type(template_sel template_type, unsigned int list_length) { if (template_type != VALUE_LIST && template_type != COMPLEMENTED_LIST&& template_type != CONJUNCTION_MATCH) TTCN_error("Setting an invalid list for a template of type @GTPC_Types.GTPC_Header_optional_part."); clean_up(); set_selection(template_type); value_list.n_values = list_length; value_list.list_value = new GTPC__Header__optional__part_template[list_length]; } GTPC__Header__optional__part_template& GTPC__Header__optional__part_template::list_item(unsigned int list_index) const { if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST&& template_selection != CONJUNCTION_MATCH) TTCN_error("Accessing a list element of a non-list template of type @GTPC_Types.GTPC_Header_optional_part."); if (list_index >= value_list.n_values) TTCN_error("Index overflow in a value list template of type @GTPC_Types.GTPC_Header_optional_part."); return value_list.list_value[list_index]; } OCTETSTRING_template& GTPC__Header__optional__part_template::sequenceNumber() { set_specific(); return single_value->field_sequenceNumber; } const OCTETSTRING_template& GTPC__Header__optional__part_template::sequenceNumber() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field sequenceNumber of a non-specific template of type @GTPC_Types.GTPC_Header_optional_part."); return single_value->field_sequenceNumber; } OCTETSTRING_template& GTPC__Header__optional__part_template::npduNumber() { set_specific(); return single_value->field_npduNumber; } const OCTETSTRING_template& GTPC__Header__optional__part_template::npduNumber() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field npduNumber of a non-specific template of type @GTPC_Types.GTPC_Header_optional_part."); return single_value->field_npduNumber; } OCTETSTRING_template& GTPC__Header__optional__part_template::nextExtHeader() { set_specific(); return single_value->field_nextExtHeader; } const OCTETSTRING_template& GTPC__Header__optional__part_template::nextExtHeader() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field nextExtHeader of a non-specific template of type @GTPC_Types.GTPC_Header_optional_part."); return single_value->field_nextExtHeader; } GTPC__ExtensionHeader__List_template& GTPC__Header__optional__part_template::gTPC__extensionHeader__List() { set_specific(); return single_value->field_gTPC__extensionHeader__List; } const GTPC__ExtensionHeader__List_template& GTPC__Header__optional__part_template::gTPC__extensionHeader__List() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field gTPC_extensionHeader_List of a non-specific template of type @GTPC_Types.GTPC_Header_optional_part."); return single_value->field_gTPC__extensionHeader__List; } int GTPC__Header__optional__part_template::size_of() const { if (is_ifpresent) TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_Header_optional_part which has an ifpresent attribute."); switch (template_selection) { case SPECIFIC_VALUE: { int ret_val = 3; if (single_value->field_gTPC__extensionHeader__List.is_present()) ret_val++; return ret_val; } case VALUE_LIST: { if (value_list.n_values<1) TTCN_error("Internal error: Performing sizeof() operation on a template of type @GTPC_Types.GTPC_Header_optional_part containing an empty list."); int item_size = value_list.list_value[0].size_of(); for (unsigned int l_idx = 1; l_idx < value_list.n_values; l_idx++) { if (value_list.list_value[l_idx].size_of()!=item_size) TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_Header_optional_part containing a value list with different sizes."); } return item_size; } case OMIT_VALUE: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_Header_optional_part containing omit value."); case ANY_VALUE: case ANY_OR_OMIT: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_Header_optional_part containing */? value."); case COMPLEMENTED_LIST: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_Header_optional_part containing complemented list."); case CONJUNCTION_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_Header_optional_part containing a conjunction list match."); case IMPLICATION_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_Header_optional_part containing an implication match."); case DYNAMIC_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_Header_optional_part containing a dynamic match."); default: TTCN_error("Performing sizeof() operation on an uninitialized/unsupported template of type @GTPC_Types.GTPC_Header_optional_part."); } return 0; } void GTPC__Header__optional__part_template::log() const { switch (template_selection) { case SPECIFIC_VALUE: TTCN_Logger::log_event_str("{ sequenceNumber := "); single_value->field_sequenceNumber.log(); TTCN_Logger::log_event_str(", npduNumber := "); single_value->field_npduNumber.log(); TTCN_Logger::log_event_str(", nextExtHeader := "); single_value->field_nextExtHeader.log(); TTCN_Logger::log_event_str(", gTPC_extensionHeader_List := "); single_value->field_gTPC__extensionHeader__List.log(); TTCN_Logger::log_event_str(" }"); break; case COMPLEMENTED_LIST: TTCN_Logger::log_event_str("complement"); case CONJUNCTION_MATCH: if (template_selection == CONJUNCTION_MATCH) { TTCN_Logger::log_event_str("conjunct"); } case VALUE_LIST: TTCN_Logger::log_char('('); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) { if (list_count > 0) TTCN_Logger::log_event_str(", "); value_list.list_value[list_count].log(); } TTCN_Logger::log_char(')'); break; case IMPLICATION_MATCH: implication_.precondition->log(); TTCN_Logger::log_event_str(" implies "); implication_.implied_template->log(); break; case DYNAMIC_MATCH: TTCN_Logger::log_event_str("@dynamic template"); break; default: log_generic(); } log_ifpresent(); } void GTPC__Header__optional__part_template::log_match(const GTPC__Header__optional__part& match_value, boolean legacy) const { if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ if(match(match_value, legacy)){ TTCN_Logger::print_logmatch_buffer(); TTCN_Logger::log_event_str(" matched"); } else{ if (template_selection == SPECIFIC_VALUE) { size_t previous_size = TTCN_Logger::get_logmatch_buffer_len(); if(!single_value->field_sequenceNumber.match(match_value.sequenceNumber(), legacy)){ TTCN_Logger::log_logmatch_info(".sequenceNumber"); single_value->field_sequenceNumber.log_match(match_value.sequenceNumber(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_npduNumber.match(match_value.npduNumber(), legacy)){ TTCN_Logger::log_logmatch_info(".npduNumber"); single_value->field_npduNumber.log_match(match_value.npduNumber(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_nextExtHeader.match(match_value.nextExtHeader(), legacy)){ TTCN_Logger::log_logmatch_info(".nextExtHeader"); single_value->field_nextExtHeader.log_match(match_value.nextExtHeader(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if (match_value.gTPC__extensionHeader__List().ispresent()){ if(!single_value->field_gTPC__extensionHeader__List.match(match_value.gTPC__extensionHeader__List(), legacy)){ TTCN_Logger::log_logmatch_info(".gTPC_extensionHeader_List"); single_value->field_gTPC__extensionHeader__List.log_match(match_value.gTPC__extensionHeader__List(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } else { if (!single_value->field_gTPC__extensionHeader__List.match_omit(legacy)){ TTCN_Logger::log_logmatch_info(".gTPC_extensionHeader_List := omit with "); TTCN_Logger::print_logmatch_buffer(); single_value->field_gTPC__extensionHeader__List.log(); TTCN_Logger::log_event_str(" unmatched"); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } }else { TTCN_Logger::print_logmatch_buffer(); match_value.log(); TTCN_Logger::log_event_str(" with "); log(); TTCN_Logger::log_event_str(" unmatched"); } } return; } if (template_selection == SPECIFIC_VALUE) { TTCN_Logger::log_event_str("{ sequenceNumber := "); single_value->field_sequenceNumber.log_match(match_value.sequenceNumber(), legacy); TTCN_Logger::log_event_str(", npduNumber := "); single_value->field_npduNumber.log_match(match_value.npduNumber(), legacy); TTCN_Logger::log_event_str(", nextExtHeader := "); single_value->field_nextExtHeader.log_match(match_value.nextExtHeader(), legacy); TTCN_Logger::log_event_str(", gTPC_extensionHeader_List := "); if (match_value.gTPC__extensionHeader__List().ispresent()) { single_value->field_gTPC__extensionHeader__List.log_match(match_value.gTPC__extensionHeader__List(), legacy); } else { TTCN_Logger::log_event_str("omit with "); single_value->field_gTPC__extensionHeader__List.log(); if (single_value->field_gTPC__extensionHeader__List.match_omit(legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } TTCN_Logger::log_event_str(" }"); } else { match_value.log(); TTCN_Logger::log_event_str(" with "); log(); if (match(match_value, legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } } void GTPC__Header__optional__part_template::encode_text(Text_Buf& text_buf) const { encode_text_base(text_buf); switch (template_selection) { case SPECIFIC_VALUE: single_value->field_sequenceNumber.encode_text(text_buf); single_value->field_npduNumber.encode_text(text_buf); single_value->field_nextExtHeader.encode_text(text_buf); single_value->field_gTPC__extensionHeader__List.encode_text(text_buf); case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: text_buf.push_int(value_list.n_values); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].encode_text(text_buf); break; default: TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of type @GTPC_Types.GTPC_Header_optional_part."); } } void GTPC__Header__optional__part_template::decode_text(Text_Buf& text_buf) { clean_up(); decode_text_base(text_buf); switch (template_selection) { case SPECIFIC_VALUE: single_value = new single_value_struct; single_value->field_sequenceNumber.decode_text(text_buf); single_value->field_npduNumber.decode_text(text_buf); single_value->field_nextExtHeader.decode_text(text_buf); single_value->field_gTPC__extensionHeader__List.decode_text(text_buf); case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: value_list.n_values = text_buf.pull_int().get_val(); value_list.list_value = new GTPC__Header__optional__part_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].decode_text(text_buf); break; default: TTCN_error("Text decoder: An unknown/unsupported selection was received in a template of type @GTPC_Types.GTPC_Header_optional_part."); } } void GTPC__Header__optional__part_template::set_param(Module_Param& param) { param.basic_check(Module_Param::BC_TEMPLATE, "record template"); switch (param.get_type()) { case Module_Param::MP_Omit: *this = OMIT_VALUE; break; case Module_Param::MP_Any: *this = ANY_VALUE; break; case Module_Param::MP_AnyOrNone: *this = ANY_OR_OMIT; break; case Module_Param::MP_List_Template: case Module_Param::MP_ComplementList_Template: case Module_Param::MP_ConjunctList_Template: { GTPC__Header__optional__part_template new_temp; new_temp.set_type(param.get_type()==Module_Param::MP_List_Template ? VALUE_LIST : (param.get_type() == Module_Param::MP_ConjunctList_Template ? CONJUNCTION_MATCH : COMPLEMENTED_LIST), param.get_size()); for (size_t p_i=0; p_i0 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) sequenceNumber().set_param(*param.get_elem(0)); if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) npduNumber().set_param(*param.get_elem(1)); if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) nextExtHeader().set_param(*param.get_elem(2)); if (param.get_size()>3 && param.get_elem(3)->get_type()!=Module_Param::MP_NotUsed) gTPC__extensionHeader__List().set_param(*param.get_elem(3)); break; case Module_Param::MP_Assignment_List: { Vector value_used(param.get_size()); value_used.resize(param.get_size(), FALSE); for (size_t val_idx=0; val_idxget_id()->get_name(), "sequenceNumber")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { sequenceNumber().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "npduNumber")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { npduNumber().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "nextExtHeader")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { nextExtHeader().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "gTPC_extensionHeader_List")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { gTPC__extensionHeader__List().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxerror("Non existent field name in type @GTPC_Types.GTPC_Header_optional_part: %s", curr_param->get_id()->get_name()); break; } } break; case Module_Param::MP_Implication_Template: { GTPC__Header__optional__part_template* precondition = new GTPC__Header__optional__part_template; precondition->set_param(*param.get_elem(0)); GTPC__Header__optional__part_template* implied_template = new GTPC__Header__optional__part_template; implied_template->set_param(*param.get_elem(1)); *this = GTPC__Header__optional__part_template(precondition, implied_template); } break; default: param.type_error("record template", "@GTPC_Types.GTPC_Header_optional_part"); } is_ifpresent = param.get_ifpresent(); } void GTPC__Header__optional__part_template::check_restriction(template_res t_res, const char* t_name, boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return; switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) { case TR_OMIT: if (template_selection==OMIT_VALUE) return; case TR_VALUE: if (template_selection!=SPECIFIC_VALUE || is_ifpresent) break; single_value->field_sequenceNumber.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_Header_optional_part"); single_value->field_npduNumber.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_Header_optional_part"); single_value->field_nextExtHeader.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_Header_optional_part"); single_value->field_gTPC__extensionHeader__List.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_Header_optional_part"); return; case TR_PRESENT: if (!match_omit(legacy)) return; break; default: return; } TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@GTPC_Types.GTPC_Header_optional_part"); } boolean GTPC__Header__optional__part_template::is_present(boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE; return !match_omit(legacy); } boolean GTPC__Header__optional__part_template::match_omit(boolean legacy) const { if (is_ifpresent) return TRUE; switch (template_selection) { case OMIT_VALUE: case ANY_OR_OMIT: return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match_omit() || implication_.implied_template->match_omit(); case VALUE_LIST: case COMPLEMENTED_LIST: if (legacy) { for (unsigned int l_idx=0; l_idxref_count = 1; val_ptr->n_elements = 0; val_ptr->value_elements = NULL; } GTPC__ExtensionHeader__List::GTPC__ExtensionHeader__List(const GTPC__ExtensionHeader__List& other_value) { if (!other_value.is_bound()) TTCN_error("Copying an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); val_ptr = other_value.val_ptr; val_ptr->ref_count++; } GTPC__ExtensionHeader__List::~GTPC__ExtensionHeader__List() { clean_up(); if (val_ptr != NULL) val_ptr = NULL; } void GTPC__ExtensionHeader__List::clean_up() { if (val_ptr != NULL) { if (val_ptr->ref_count > 1) { val_ptr->ref_count--; val_ptr = NULL; } else if (val_ptr->ref_count == 1) { for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) if (val_ptr->value_elements[elem_count] != NULL) delete val_ptr->value_elements[elem_count]; free_pointers((void**)val_ptr->value_elements); delete val_ptr; val_ptr = NULL; } else TTCN_error("Internal error: Invalid reference counter in a record of/set of value."); } } GTPC__ExtensionHeader__List& GTPC__ExtensionHeader__List::operator=(null_type) { clean_up(); val_ptr = new recordof_setof_struct; val_ptr->ref_count = 1; val_ptr->n_elements = 0; val_ptr->value_elements = NULL; return *this; } GTPC__ExtensionHeader__List& GTPC__ExtensionHeader__List::operator=(const GTPC__ExtensionHeader__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("Assigning an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); if (this != &other_value) { clean_up(); val_ptr = other_value.val_ptr; val_ptr->ref_count++; } return *this; } boolean GTPC__ExtensionHeader__List::operator==(null_type) const { if (val_ptr == NULL) TTCN_error("The left operand of comparison is an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); return val_ptr->n_elements == 0 ; } boolean GTPC__ExtensionHeader__List::operator==(const GTPC__ExtensionHeader__List& other_value) const { if (val_ptr == NULL) TTCN_error("The left operand of comparison is an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); if (val_ptr == other_value.val_ptr) return TRUE; if (val_ptr->n_elements != (other_value.val_ptr)->n_elements) return FALSE; for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++){ if (val_ptr->value_elements[elem_count] != NULL){ if ((other_value.val_ptr)->value_elements[elem_count] != NULL){ if (*val_ptr->value_elements[elem_count] != *(other_value.val_ptr)->value_elements[elem_count]) return FALSE; } else return FALSE; } else { if ((other_value.val_ptr)->value_elements[elem_count] != NULL) return FALSE; } } return TRUE; } GTPC__ExtensionHeader& GTPC__ExtensionHeader__List::operator[](int index_value) { if (index_value < 0) TTCN_error("Accessing an element of type @GTPC_Types.GTPC_ExtensionHeader_List using a negative index: %d.", index_value); if (val_ptr == NULL) { val_ptr = new recordof_setof_struct; val_ptr->ref_count = 1; val_ptr->n_elements = 0; val_ptr->value_elements = NULL; } else if (val_ptr->ref_count > 1) { struct recordof_setof_struct *new_val_ptr = new recordof_setof_struct; new_val_ptr->ref_count = 1; new_val_ptr->n_elements = (index_value >= val_ptr->n_elements) ? index_value + 1 : val_ptr->n_elements; new_val_ptr->value_elements = (GTPC__ExtensionHeader**)allocate_pointers(new_val_ptr->n_elements); for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++){ if (val_ptr->value_elements[elem_count] != NULL){ new_val_ptr->value_elements[elem_count] = new GTPC__ExtensionHeader(*(val_ptr->value_elements[elem_count])); } } clean_up(); val_ptr = new_val_ptr; } if (index_value >= val_ptr->n_elements) set_size(index_value + 1); if (val_ptr->value_elements[index_value] == NULL) { val_ptr->value_elements[index_value] = new GTPC__ExtensionHeader; } return *val_ptr->value_elements[index_value]; } GTPC__ExtensionHeader& GTPC__ExtensionHeader__List::operator[](const INTEGER& index_value) { index_value.must_bound("Using an unbound integer value for indexing a value of type @GTPC_Types.GTPC_ExtensionHeader_List."); return (*this)[(int)index_value]; } const GTPC__ExtensionHeader& GTPC__ExtensionHeader__List::operator[](int index_value) const { if (val_ptr == NULL) TTCN_error("Accessing an element in an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); if (index_value < 0) TTCN_error("Accessing an element of type @GTPC_Types.GTPC_ExtensionHeader_List using a negative index: %d.", index_value); if (index_value >= val_ptr->n_elements) TTCN_error("Index overflow in a value of type @GTPC_Types.GTPC_ExtensionHeader_List: The index is %d, but the value has only %d elements.", index_value, val_ptr->n_elements); return (val_ptr->value_elements[index_value] == NULL) ? UNBOUND_ELEM : *val_ptr->value_elements[index_value]; } const GTPC__ExtensionHeader& GTPC__ExtensionHeader__List::operator[](const INTEGER& index_value) const { index_value.must_bound("Using an unbound integer value for indexing a value of type @GTPC_Types.GTPC_ExtensionHeader_List."); return (*this)[(int)index_value]; } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List::operator<<=(int rotate_count) const { return *this >>= (-rotate_count); } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List::operator<<=(const INTEGER& rotate_count) const { rotate_count.must_bound("Unbound integer operand of rotate left operator."); return *this >>= (int)(-rotate_count); } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List::operator>>=(const INTEGER& rotate_count) const { rotate_count.must_bound("Unbound integer operand of rotate right operator."); return *this >>= (int)rotate_count; } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List::operator>>=(int rotate_count) const { if (val_ptr == NULL) TTCN_error("Performing rotation operation on an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); if (val_ptr->n_elements == 0) return *this; int rc; if (rotate_count>=0) rc = rotate_count % val_ptr->n_elements; else rc = val_ptr->n_elements - ((-rotate_count) % val_ptr->n_elements); if (rc == 0) return *this; GTPC__ExtensionHeader__List ret_val; ret_val.set_size(val_ptr->n_elements); for (int i=0; in_elements; i++) { if (val_ptr->value_elements[i] != NULL) { ret_val.val_ptr->value_elements[(i+rc)%val_ptr->n_elements] =new GTPC__ExtensionHeader(*val_ptr->value_elements[i]); } } return ret_val; } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List::operator+(const GTPC__ExtensionHeader__List& other_value) const { if (val_ptr == NULL || other_value.val_ptr == NULL) TTCN_error("Unbound operand of @GTPC_Types.GTPC_ExtensionHeader_List concatenation."); if (val_ptr->n_elements == 0) return other_value; if (other_value.val_ptr->n_elements == 0) return *this; GTPC__ExtensionHeader__List ret_val; ret_val.set_size(val_ptr->n_elements+other_value.val_ptr->n_elements); for (int i=0; in_elements; i++) { if (val_ptr->value_elements[i] != NULL) { ret_val.val_ptr->value_elements[i] = new GTPC__ExtensionHeader(*val_ptr->value_elements[i]); } } for (int i=0; in_elements; i++) { if (other_value.val_ptr->value_elements[i] != NULL) { ret_val.val_ptr->value_elements[i+val_ptr->n_elements] = new GTPC__ExtensionHeader(*other_value.val_ptr->value_elements[i]); } } return ret_val; } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List::substr(int index, int returncount) const { if (val_ptr == NULL) TTCN_error("The first argument of substr() is an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); check_substr_arguments(val_ptr->n_elements, index, returncount, "@GTPC_Types.GTPC_ExtensionHeader_List","element"); GTPC__ExtensionHeader__List ret_val; ret_val.set_size(returncount); for (int i=0; ivalue_elements[i+index] != NULL) { ret_val.val_ptr->value_elements[i] = new GTPC__ExtensionHeader(*val_ptr->value_elements[i+index]); } } return ret_val; } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List::replace(int index, int len, const GTPC__ExtensionHeader__List& repl) const { if (val_ptr == NULL) TTCN_error("The first argument of replace() is an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); if (repl.val_ptr == NULL) TTCN_error("The fourth argument of replace() is an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); check_replace_arguments(val_ptr->n_elements, index, len, "@GTPC_Types.GTPC_ExtensionHeader_List","element"); GTPC__ExtensionHeader__List ret_val; ret_val.set_size(val_ptr->n_elements + repl.val_ptr->n_elements - len); for (int i = 0; i < index; i++) { if (val_ptr->value_elements[i] != NULL) { ret_val.val_ptr->value_elements[i] = new GTPC__ExtensionHeader(*val_ptr->value_elements[i]); } } for (int i = 0; i < repl.val_ptr->n_elements; i++) { if (repl.val_ptr->value_elements[i] != NULL) { ret_val.val_ptr->value_elements[i+index] = new GTPC__ExtensionHeader(*repl.val_ptr->value_elements[i]); } } for (int i = 0; i < val_ptr->n_elements - index - len; i++) { if (val_ptr->value_elements[index+i+len] != NULL) { ret_val.val_ptr->value_elements[index+i+repl.val_ptr->n_elements] = new GTPC__ExtensionHeader(*val_ptr->value_elements[index+i+len]); } } return ret_val; } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List::replace(int index, int len, const GTPC__ExtensionHeader__List_template& repl) const { if (!repl.is_value()) TTCN_error("The fourth argument of function replace() is a template with non-specific value."); return replace(index, len, repl.valueof()); } void GTPC__ExtensionHeader__List::set_size(int new_size) { if (new_size < 0) TTCN_error("Internal error: Setting a negative size for a value of type @GTPC_Types.GTPC_ExtensionHeader_List."); if (val_ptr == NULL) { val_ptr = new recordof_setof_struct; val_ptr->ref_count = 1; val_ptr->n_elements = 0; val_ptr->value_elements = NULL; } else if (val_ptr->ref_count > 1) { struct recordof_setof_struct *new_val_ptr = new recordof_setof_struct; new_val_ptr->ref_count = 1; new_val_ptr->n_elements = (new_size < val_ptr->n_elements) ? new_size : val_ptr->n_elements; new_val_ptr->value_elements = (GTPC__ExtensionHeader**)allocate_pointers(new_val_ptr->n_elements); for (int elem_count = 0; elem_count < new_val_ptr->n_elements; elem_count++) { if (val_ptr->value_elements[elem_count] != NULL){ new_val_ptr->value_elements[elem_count] = new GTPC__ExtensionHeader(*(val_ptr->value_elements[elem_count])); } } clean_up(); val_ptr = new_val_ptr; } if (new_size > val_ptr->n_elements) { val_ptr->value_elements = (GTPC__ExtensionHeader**)reallocate_pointers((void**)val_ptr->value_elements, val_ptr->n_elements, new_size); #ifdef TITAN_MEMORY_DEBUG_SET_RECORD_OF if((val_ptr->n_elements/1000)!=(new_size/1000)) TTCN_warning("New size of type @GTPC_Types.GTPC_ExtensionHeader_List: %d",new_size); #endif val_ptr->n_elements = new_size; } else if (new_size < val_ptr->n_elements) { for (int elem_count = new_size; elem_count < val_ptr->n_elements; elem_count++) if (val_ptr->value_elements[elem_count] != NULL)delete val_ptr->value_elements[elem_count]; val_ptr->value_elements = (GTPC__ExtensionHeader**)reallocate_pointers((void**)val_ptr->value_elements, val_ptr->n_elements, new_size); val_ptr->n_elements = new_size; } } boolean GTPC__ExtensionHeader__List::is_value() const { if (val_ptr == NULL) return FALSE; for(int i = 0; i < val_ptr->n_elements; ++i) { if (val_ptr->value_elements[i] == NULL || !val_ptr->value_elements[i]->is_value()) return FALSE; } return TRUE; } int GTPC__ExtensionHeader__List::size_of() const { if (val_ptr == NULL) TTCN_error("Performing sizeof operation on an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); return val_ptr->n_elements; } int GTPC__ExtensionHeader__List::lengthof() const { if (val_ptr == NULL) TTCN_error("Performing lengthof operation on an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); for (int my_length=val_ptr->n_elements; my_length>0; my_length--) if (val_ptr->value_elements[my_length-1] != NULL) return my_length; return 0; } void GTPC__ExtensionHeader__List::log() const { if (val_ptr == NULL) {; TTCN_Logger::log_event_unbound(); return; } switch (val_ptr->n_elements) { case 0: TTCN_Logger::log_event_str("{ }"); break; default: TTCN_Logger::log_event_str("{ "); for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) { if (elem_count > 0) TTCN_Logger::log_event_str(", "); (*this)[elem_count].log(); } TTCN_Logger::log_event_str(" }"); } } void GTPC__ExtensionHeader__List::set_implicit_omit() { if (val_ptr == NULL) return; for (int i = 0; i < val_ptr->n_elements; i++) { if (val_ptr->value_elements[i] != NULL) val_ptr->value_elements[i]->set_implicit_omit(); } } void GTPC__ExtensionHeader__List::set_param(Module_Param& param) { param.basic_check(Module_Param::BC_VALUE|Module_Param::BC_LIST, "record of value"); switch (param.get_operation_type()) { case Module_Param::OT_ASSIGN: if (param.get_type()==Module_Param::MP_Value_List && param.get_size()==0) { *this = NULL_VALUE; return; } switch (param.get_type()) { case Module_Param::MP_Value_List: set_size(param.get_size()); for (size_t i=0; iget_type()!=Module_Param::MP_NotUsed) { (*this)[i].set_param(*curr); if (!(*this)[i].is_bound()) { delete val_ptr->value_elements[i]; val_ptr->value_elements[i] = NULL; } } } break; case Module_Param::MP_Indexed_List: for (size_t i=0; iget_id()->get_index()].set_param(*curr); if (!(*this)[curr->get_id()->get_index()].is_bound()) { delete val_ptr->value_elements[curr->get_id()->get_index()]; val_ptr->value_elements[curr->get_id()->get_index()] = NULL; } } break; default: param.type_error("record of value", "@GTPC_Types.GTPC_ExtensionHeader_List"); } break; case Module_Param::OT_CONCAT: switch (param.get_type()) { case Module_Param::MP_Value_List: { if (!is_bound()) *this = NULL_VALUE; int start_idx = lengthof(); for (size_t i=0; iget_type()!=Module_Param::MP_NotUsed)) { (*this)[start_idx+(int)i].set_param(*curr); } } } break; case Module_Param::MP_Indexed_List: param.error("Cannot concatenate an indexed value list"); break; default: param.type_error("record of value", "@GTPC_Types.GTPC_ExtensionHeader_List"); } break; default: TTCN_error("Internal error: Unknown operation type."); } } void GTPC__ExtensionHeader__List::encode_text(Text_Buf& text_buf) const { if (val_ptr == NULL) TTCN_error("Text encoder: Encoding an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); text_buf.push_int(val_ptr->n_elements); for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) (*this)[elem_count].encode_text(text_buf); } void GTPC__ExtensionHeader__List::decode_text(Text_Buf& text_buf) { clean_up(); val_ptr = new recordof_setof_struct; val_ptr->ref_count = 1; val_ptr->n_elements = text_buf.pull_int().get_val(); if (val_ptr->n_elements < 0) TTCN_error("Text decoder: Negative size was received for a value of type @GTPC_Types.GTPC_ExtensionHeader_List."); val_ptr->value_elements = (GTPC__ExtensionHeader**)allocate_pointers(val_ptr->n_elements); for (int elem_count = 0; elem_count < val_ptr->n_elements; elem_count++) { val_ptr->value_elements[elem_count] = new GTPC__ExtensionHeader; val_ptr->value_elements[elem_count]->decode_text(text_buf); } } void GTPC__ExtensionHeader__List::encode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) const { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-encoding type '%s': ", p_td.name); unsigned BER_coding=va_arg(pvar, unsigned); BER_encode_chk_coding(BER_coding); ASN_BER_TLV_t *tlv=BER_encode_TLV(p_td, BER_coding); tlv->put_in_buffer(p_buf); ASN_BER_TLV_t::destruct(tlv); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-encoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); RAW_enc_tr_pos rp; rp.level=0; rp.pos=NULL; RAW_enc_tree root(FALSE, NULL, &rp, 1, p_td.raw); RAW_encode(p_td, root); root.put_to_buf(p_buf); break;} case TTCN_EncDec::CT_TEXT: { TTCN_EncDec_ErrorContext ec("While TEXT-encoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); TEXT_encode(p_td,p_buf); break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-encoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XER_encode(*(p_td.xer),p_buf, XER_coding, 0, 0, 0); p_buf.put_c('\n'); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-encoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok(va_arg(pvar, int) != 0); JSON_encode(p_td, tok, FALSE); p_buf.put_s(tok.get_buffer_length(), (const unsigned char*)tok.get_buffer()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-encoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_encode(p_td, p_buf); break;} default: TTCN_error("Unknown coding method requested to encode type '%s'", p_td.name); } va_end(pvar); } void GTPC__ExtensionHeader__List::decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-decoding type '%s': ", p_td.name); unsigned L_form=va_arg(pvar, unsigned); ASN_BER_TLV_t tlv; BER_decode_str2TLV(p_buf, tlv, L_form); BER_decode_TLV(p_td, tlv, L_form); if(tlv.isComplete) p_buf.increase_pos(tlv.get_len()); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-decoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); raw_order_t r_order; switch(p_td.raw->top_bit_order) { case TOP_BIT_LEFT: r_order=ORDER_LSB; break; case TOP_BIT_RIGHT: default: r_order=ORDER_MSB; } int rawr = RAW_decode(p_td, p_buf, p_buf.get_len()*8, r_order); if(rawr<0) switch (-rawr) { case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: ec.error((TTCN_EncDec::error_type_t)-rawr, "Can not decode type '%s', because incomplete message was received", p_td.name); break; case 1: default: ec.error(TTCN_EncDec::ET_INVAL_MSG, "Can not decode type '%s', because invalid message was received", p_td.name); break; } break;} case TTCN_EncDec::CT_TEXT: { Limit_Token_List limit; TTCN_EncDec_ErrorContext ec("While TEXT-decoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); const unsigned char *b_data=p_buf.get_data(); int null_added=0; if(b_data[p_buf.get_len()-1]!='\0'){ null_added=1; p_buf.set_pos(p_buf.get_len()); p_buf.put_zero(8,ORDER_LSB); p_buf.rewind(); } if(TEXT_decode(p_td,p_buf,limit)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); if(null_added){ size_t actpos=p_buf.get_pos(); p_buf.set_pos(p_buf.get_len()-1); p_buf.cut_end(); p_buf.set_pos(actpos); } break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-decoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XmlReaderWrap reader(p_buf); for (int rd_ok=reader.Read(); rd_ok==1; rd_ok=reader.Read()) { if (reader.NodeType() == XML_READER_TYPE_ELEMENT) break; } XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL, XER_NONE, 0); size_t bytes = reader.ByteConsumed(); p_buf.set_pos(bytes); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-decoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok((const char*)p_buf.get_data(), p_buf.get_len()); if(JSON_decode(p_td, tok, FALSE, FALSE)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); p_buf.set_pos(tok.get_buf_pos()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-decoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_struct p_oer; OER_decode(p_td, p_buf, p_oer); break;} default: TTCN_error("Unknown coding method requested to decode type '%s'", p_td.name); } va_end(pvar); } int GTPC__ExtensionHeader__List::RAW_decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int limit, raw_order_t top_bit_ord, boolean /*no_err*/, int sel_field, boolean first_call, const RAW_Force_Omit*){ int prepaddlength=p_buf.increase_pos_padd(p_td.raw->prepadding); limit-=prepaddlength; int decoded_length=0; int decoded_field_length=0; size_t start_of_field=0; if(first_call) { clean_up(); val_ptr=new recordof_setof_struct; val_ptr->ref_count=1; val_ptr->n_elements=0; val_ptr->value_elements=NULL; } int start_field=val_ptr->n_elements; if(p_td.raw->fieldlength || sel_field!=-1){ int a=0; if(sel_field==-1) sel_field=p_td.raw->fieldlength; start_of_field=p_buf.get_pos_bit(); for(a=0;a=0){ delete &(*this)[a+start_field]; a--; val_ptr->n_elements--; } p_buf.set_pos_bit(start_of_field); return decoded_field_length; } decoded_length+=decoded_field_length; limit-=decoded_field_length; } if(a==0) val_ptr->n_elements=0; } else { if(limit==0){ if(!first_call) return -1; val_ptr->n_elements=0; return decoded_length+p_buf.increase_pos_padd(p_td.raw->padding)+prepaddlength; } int a=start_field; while(limit>0){ start_of_field=p_buf.get_pos_bit(); decoded_field_length=(*this)[a].RAW_decode(*p_td.oftype_descr,p_buf,limit,top_bit_ord,TRUE); if(decoded_field_length < 0){ delete &(*this)[a]; val_ptr->n_elements--; p_buf.set_pos_bit(start_of_field); if(a>start_field){ return decoded_length+p_buf.increase_pos_padd(p_td.raw->padding)+prepaddlength; } else return -1; } decoded_length+=decoded_field_length; limit-=decoded_field_length; a++; } } return decoded_length+p_buf.increase_pos_padd(p_td.raw->padding)+prepaddlength; } int GTPC__ExtensionHeader__List::RAW_encode(const TTCN_Typedescriptor_t& p_td,RAW_enc_tree& myleaf) const{ int encoded_length=0; int encoded_num_of_records=p_td.raw->fieldlength?smaller(val_ptr->n_elements, p_td.raw->fieldlength):val_ptr->n_elements; myleaf.isleaf=FALSE; myleaf.rec_of=TRUE; myleaf.body.node.num_of_nodes=encoded_num_of_records; myleaf.body.node.nodes=init_nodes_of_enc_tree(encoded_num_of_records); for(int a=0;araw); encoded_length+=(*this)[a].RAW_encode(*p_td.oftype_descr,*myleaf.body.node.nodes[a]); } return myleaf.length=encoded_length; } void GTPC__ExtensionHeader__List_template::copy_value(const GTPC__ExtensionHeader__List& other_value) { if (!other_value.is_bound()) TTCN_error("Initialization of a template of type @GTPC_Types.GTPC_ExtensionHeader_List with an unbound value."); single_value.n_elements = other_value.size_of(); single_value.value_elements = (GTPC__ExtensionHeader_template**)allocate_pointers(single_value.n_elements); for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) { if (other_value[elem_count].is_bound()) { single_value.value_elements[elem_count] = new GTPC__ExtensionHeader_template(other_value[elem_count]); } else { single_value.value_elements[elem_count] = new GTPC__ExtensionHeader_template; } } set_selection(SPECIFIC_VALUE); } void GTPC__ExtensionHeader__List_template::copy_template(const GTPC__ExtensionHeader__List_template& other_value) { switch (other_value.template_selection) { case SPECIFIC_VALUE: single_value.n_elements = other_value.single_value.n_elements; single_value.value_elements = (GTPC__ExtensionHeader_template**)allocate_pointers(single_value.n_elements); for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) { if (UNINITIALIZED_TEMPLATE != other_value.single_value.value_elements[elem_count]->get_selection()) { single_value.value_elements[elem_count] = new GTPC__ExtensionHeader_template(*other_value.single_value.value_elements[elem_count]); } else { single_value.value_elements[elem_count] = new GTPC__ExtensionHeader_template; } } case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: value_list.n_values = other_value.value_list.n_values; value_list.list_value = new GTPC__ExtensionHeader__List_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]); break; case IMPLICATION_MATCH: implication_.precondition = new GTPC__ExtensionHeader__List_template(*other_value.implication_.precondition); implication_.implied_template = new GTPC__ExtensionHeader__List_template(*other_value.implication_.implied_template); break; case DYNAMIC_MATCH: dyn_match = other_value.dyn_match; dyn_match->ref_count++; break; default: TTCN_error("Copying an uninitialized/unsupported template of type @GTPC_Types.GTPC_ExtensionHeader_List."); break; } set_selection(other_value); } boolean GTPC__ExtensionHeader__List_template::match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy) { if (value_index >= 0) return ((const GTPC__ExtensionHeader__List_template*)template_ptr)->single_value.value_elements[template_index]->match((*(const GTPC__ExtensionHeader__List*)value_ptr)[value_index], legacy); else return ((const GTPC__ExtensionHeader__List_template*)template_ptr)->single_value.value_elements[template_index]->is_any_or_omit(); } GTPC__ExtensionHeader__List_template::GTPC__ExtensionHeader__List_template() { } GTPC__ExtensionHeader__List_template::GTPC__ExtensionHeader__List_template(template_sel other_value) : Base_Record_Of_Template(other_value) { check_single_selection(other_value); } GTPC__ExtensionHeader__List_template::GTPC__ExtensionHeader__List_template(null_type) : Base_Record_Of_Template(SPECIFIC_VALUE) { single_value.n_elements = 0; single_value.value_elements = NULL; } GTPC__ExtensionHeader__List_template::GTPC__ExtensionHeader__List_template(const GTPC__ExtensionHeader__List& other_value) { copy_value(other_value); } GTPC__ExtensionHeader__List_template::GTPC__ExtensionHeader__List_template(const OPTIONAL& other_value) { switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const GTPC__ExtensionHeader__List&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Creating a template of type @GTPC_Types.GTPC_ExtensionHeader_List from an unbound optional field."); } } GTPC__ExtensionHeader__List_template::GTPC__ExtensionHeader__List_template(GTPC__ExtensionHeader__List_template* p_precondition, GTPC__ExtensionHeader__List_template* p_implied_template) : Base_Record_Of_Template(IMPLICATION_MATCH) { implication_.precondition = p_precondition; implication_.implied_template = p_implied_template; } GTPC__ExtensionHeader__List_template::GTPC__ExtensionHeader__List_template(Dynamic_Match_Interface* p_dyn_match) : Base_Record_Of_Template(DYNAMIC_MATCH) { dyn_match = new dynmatch_struct; dyn_match->ptr = p_dyn_match; dyn_match->ref_count = 1; } GTPC__ExtensionHeader__List_template::GTPC__ExtensionHeader__List_template(const GTPC__ExtensionHeader__List_template& other_value) : Base_Record_Of_Template() { copy_template(other_value); } GTPC__ExtensionHeader__List_template::~GTPC__ExtensionHeader__List_template() { clean_up(); } void GTPC__ExtensionHeader__List_template::clean_up() { switch (template_selection) { case SPECIFIC_VALUE: for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) delete single_value.value_elements[elem_count]; free_pointers((void**)single_value.value_elements); break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: delete [] value_list.list_value; break; case IMPLICATION_MATCH: delete implication_.precondition; delete implication_.implied_template; break; case DYNAMIC_MATCH: dyn_match->ref_count--; if (dyn_match->ref_count == 0) { delete dyn_match->ptr; delete dyn_match; } break; default: break; } template_selection = UNINITIALIZED_TEMPLATE; } GTPC__ExtensionHeader__List_template& GTPC__ExtensionHeader__List_template::operator=(template_sel other_value) { check_single_selection(other_value); clean_up(); set_selection(other_value); return *this; } GTPC__ExtensionHeader__List_template& GTPC__ExtensionHeader__List_template::operator=(null_type) { clean_up(); set_selection(SPECIFIC_VALUE); single_value.n_elements = 0; single_value.value_elements = NULL; return *this; } GTPC__ExtensionHeader__List_template& GTPC__ExtensionHeader__List_template::operator=(const GTPC__ExtensionHeader__List& other_value) { clean_up(); copy_value(other_value); return *this; } GTPC__ExtensionHeader__List_template& GTPC__ExtensionHeader__List_template::operator=(const OPTIONAL& other_value) { clean_up(); switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const GTPC__ExtensionHeader__List&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Assignment of an unbound optional field to a template of type @GTPC_Types.GTPC_ExtensionHeader_List."); } return *this; } GTPC__ExtensionHeader__List_template& GTPC__ExtensionHeader__List_template::operator=(const GTPC__ExtensionHeader__List_template& other_value) { if (&other_value != this) { clean_up(); copy_template(other_value); } return *this; } GTPC__ExtensionHeader_template& GTPC__ExtensionHeader__List_template::operator[](int index_value) { if (index_value < 0) TTCN_error("Accessing an element of a template for type @GTPC_Types.GTPC_ExtensionHeader_List using a negative index: %d.", index_value); switch (template_selection) { case SPECIFIC_VALUE: if(index_value < single_value.n_elements) break; // no break case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: case UNINITIALIZED_TEMPLATE: set_size(index_value + 1); break; default: TTCN_error("Accessing an element of a non-specific template for type @GTPC_Types.GTPC_ExtensionHeader_List."); break; } return *single_value.value_elements[index_value]; } GTPC__ExtensionHeader_template& GTPC__ExtensionHeader__List_template::operator[](const INTEGER& index_value) { index_value.must_bound("Using an unbound integer value for indexing a template of type @GTPC_Types.GTPC_ExtensionHeader_List."); return (*this)[(int)index_value]; } const GTPC__ExtensionHeader_template& GTPC__ExtensionHeader__List_template::operator[](int index_value) const { if (index_value < 0) TTCN_error("Accessing an element of a template for type @GTPC_Types.GTPC_ExtensionHeader_List using a negative index: %d.", index_value); if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing an element of a non-specific template for type @GTPC_Types.GTPC_ExtensionHeader_List."); if (index_value >= single_value.n_elements) TTCN_error("Index overflow in a template of type @GTPC_Types.GTPC_ExtensionHeader_List: The index is %d, but the template has only %d elements.", index_value, single_value.n_elements); return *single_value.value_elements[index_value]; } const GTPC__ExtensionHeader_template& GTPC__ExtensionHeader__List_template::operator[](const INTEGER& index_value) const { index_value.must_bound("Using an unbound integer value for indexing a template of type @GTPC_Types.GTPC_ExtensionHeader_List."); return (*this)[(int)index_value]; } void GTPC__ExtensionHeader__List_template::set_size(int new_size) { if (new_size < 0) TTCN_error("Internal error: Setting a negative size for a template of type @GTPC_Types.GTPC_ExtensionHeader_List."); template_sel old_selection = template_selection; if (old_selection != SPECIFIC_VALUE) { clean_up(); set_selection(SPECIFIC_VALUE); single_value.n_elements = 0; single_value.value_elements = NULL; } if (new_size > single_value.n_elements) { single_value.value_elements = (GTPC__ExtensionHeader_template**)reallocate_pointers((void**)single_value.value_elements, single_value.n_elements, new_size); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) { for (int elem_count = single_value.n_elements; elem_count < new_size; elem_count++) single_value.value_elements[elem_count] = new GTPC__ExtensionHeader_template(ANY_VALUE); } else { for (int elem_count = single_value.n_elements; elem_count < new_size; elem_count++) single_value.value_elements[elem_count] = new GTPC__ExtensionHeader_template; } single_value.n_elements = new_size; } else if (new_size < single_value.n_elements) { for (int elem_count = new_size; elem_count < single_value.n_elements; elem_count++) delete single_value.value_elements[elem_count]; single_value.value_elements = (GTPC__ExtensionHeader_template**)reallocate_pointers((void**)single_value.value_elements, single_value.n_elements, new_size); single_value.n_elements = new_size; } } int GTPC__ExtensionHeader__List_template::n_elem() const { switch (template_selection) { case SPECIFIC_VALUE: return single_value.n_elements; break; case VALUE_LIST: return value_list.n_values; break; default: TTCN_error("Performing n_elem"); } } int GTPC__ExtensionHeader__List_template::size_of(boolean is_size) const { const char* op_name = is_size ? "size" : "length"; int min_size; boolean has_any_or_none; if (is_ifpresent) TTCN_error("Performing %sof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader_List which has an ifpresent attribute.", op_name); switch (template_selection) { case SPECIFIC_VALUE: { min_size = 0; has_any_or_none = FALSE; int elem_count = single_value.n_elements; if (!is_size) { while (elem_count>0 && !single_value.value_elements[elem_count-1]->is_bound()) elem_count--; } for (int i=0; iget_selection()) { case OMIT_VALUE: TTCN_error("Performing %sof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader_List containing omit element.", op_name); case ANY_OR_OMIT: has_any_or_none = TRUE; break; default: min_size++; break; } } } break; case OMIT_VALUE: TTCN_error("Performing %sof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader_List containing omit value.", op_name); case ANY_VALUE: case ANY_OR_OMIT: min_size = 0; has_any_or_none = TRUE; break; case VALUE_LIST: { if (value_list.n_values<1) TTCN_error("Performing %sof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader_List containing an empty list.", op_name); int item_size = value_list.list_value[0].size_of(is_size); for (unsigned int i = 1; i < value_list.n_values; i++) { if (value_list.list_value[i].size_of(is_size)!=item_size) TTCN_error("Performing %sof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader_List containing a value list with different sizes.", op_name); } min_size = item_size; has_any_or_none = FALSE; break; } case COMPLEMENTED_LIST: TTCN_error("Performing %sof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader_List containing complemented list.", op_name); default: TTCN_error("Performing %sof() operation on an uninitialized/unsupported template of type @GTPC_Types.GTPC_ExtensionHeader_List.", op_name); } return check_section_is_single(min_size, has_any_or_none, op_name, "a", "template of type @GTPC_Types.GTPC_ExtensionHeader_List"); } boolean GTPC__ExtensionHeader__List_template::match(const GTPC__ExtensionHeader__List& other_value, boolean legacy) const { if (!other_value.is_bound()) return FALSE; int value_length = other_value.size_of(); if (!match_length(value_length)) return FALSE; switch (template_selection) { case SPECIFIC_VALUE: return match_record_of(&other_value, value_length, this, single_value.n_elements, match_function_specific, legacy); case OMIT_VALUE: return FALSE; case ANY_VALUE: case ANY_OR_OMIT: return TRUE; case VALUE_LIST: case COMPLEMENTED_LIST: for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) if (value_list.list_value[list_count].match(other_value, legacy)) return template_selection == VALUE_LIST; return template_selection == COMPLEMENTED_LIST; case CONJUNCTION_MATCH: for (unsigned int i = 0; i < value_list.n_values; i++) { if (!value_list.list_value[i].match(other_value)) { return FALSE; } } return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value); case DYNAMIC_MATCH: return dyn_match->ptr->match(other_value); default: TTCN_error("Matching with an uninitialized/unsupported template of type @GTPC_Types.GTPC_ExtensionHeader_List."); } return FALSE; } boolean GTPC__ExtensionHeader__List_template::is_value() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE; for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) if (!single_value.value_elements[elem_count]->is_value()) return FALSE; return TRUE; } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List_template::valueof() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of type @GTPC_Types.GTPC_ExtensionHeader_List."); GTPC__ExtensionHeader__List ret_val; ret_val.set_size(single_value.n_elements); for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) if (single_value.value_elements[elem_count]->is_bound()) { ret_val[elem_count] = single_value.value_elements[elem_count]->valueof(); } return ret_val; } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List_template::substr(int index, int returncount) const { if (!is_value()) TTCN_error("The first argument of function substr() is a template with non-specific value."); return valueof().substr(index, returncount); } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List_template::replace(int index, int len, const GTPC__ExtensionHeader__List_template& repl) const { if (!is_value()) TTCN_error("The first argument of function replace() is a template with non-specific value."); if (!repl.is_value()) TTCN_error("The fourth argument of function replace() is a template with non-specific value."); return valueof().replace(index, len, repl.valueof()); } GTPC__ExtensionHeader__List GTPC__ExtensionHeader__List_template::replace(int index, int len, const GTPC__ExtensionHeader__List& repl) const { if (!is_value()) TTCN_error("The first argument of function replace() is a template with non-specific value."); return valueof().replace(index, len, repl); } void GTPC__ExtensionHeader__List_template::set_type(template_sel template_type, unsigned int list_length) { clean_up(); switch (template_type) { case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: value_list.n_values = list_length; value_list.list_value = new GTPC__ExtensionHeader__List_template[list_length]; break; default: TTCN_error("Internal error: Setting an invalid type for a template of type @GTPC_Types.GTPC_ExtensionHeader_List."); } set_selection(template_type); } GTPC__ExtensionHeader__List_template& GTPC__ExtensionHeader__List_template::list_item(unsigned int list_index) { if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST && template_selection != CONJUNCTION_MATCH) TTCN_error("Internal error: Accessing a list element of a non-list template of type @GTPC_Types.GTPC_ExtensionHeader_List."); if (list_index >= value_list.n_values) TTCN_error("Internal error: Index overflow in a value list template of type @GTPC_Types.GTPC_ExtensionHeader_List."); return value_list.list_value[list_index]; } void GTPC__ExtensionHeader__List_template::log() const { switch (template_selection) { case SPECIFIC_VALUE: if (single_value.n_elements > 0) { TTCN_Logger::log_event_str("{ "); for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) { if (elem_count > 0) TTCN_Logger::log_event_str(", "); if (permutation_starts_at(elem_count)) TTCN_Logger::log_event_str("permutation("); single_value.value_elements[elem_count]->log(); if (permutation_ends_at(elem_count)) TTCN_Logger::log_char(')'); } TTCN_Logger::log_event_str(" }"); } else TTCN_Logger::log_event_str("{ }"); break; case COMPLEMENTED_LIST: TTCN_Logger::log_event_str("complement"); case CONJUNCTION_MATCH: if (template_selection == CONJUNCTION_MATCH) { TTCN_Logger::log_event_str("conjunct"); } case VALUE_LIST: TTCN_Logger::log_char('('); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) { if (list_count > 0) TTCN_Logger::log_event_str(", "); value_list.list_value[list_count].log(); } TTCN_Logger::log_char(')'); break; case IMPLICATION_MATCH: implication_.precondition->log(); TTCN_Logger::log_event_str(" implies "); implication_.implied_template->log(); break; case DYNAMIC_MATCH: TTCN_Logger::log_event_str("@dynamic template"); break; default: log_generic(); } log_restricted(); log_ifpresent(); } void GTPC__ExtensionHeader__List_template::log_match(const GTPC__ExtensionHeader__List& match_value, boolean legacy) const { if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ if(match(match_value, legacy)){ TTCN_Logger::print_logmatch_buffer(); TTCN_Logger::log_event_str(" matched"); }else{ if (template_selection == SPECIFIC_VALUE && single_value.n_elements > 0 && get_number_of_permutations() == 0 && single_value.n_elements == match_value.size_of()) { size_t previous_size = TTCN_Logger::get_logmatch_buffer_len(); for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) { if(!single_value.value_elements[elem_count]->match(match_value[elem_count], legacy)){ TTCN_Logger::log_logmatch_info("[%d]", elem_count); single_value.value_elements[elem_count]->log_match(match_value[elem_count], legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } } log_match_length(single_value.n_elements); } else { TTCN_Logger::print_logmatch_buffer(); match_value.log(); TTCN_Logger::log_event_str(" with "); log(); TTCN_Logger::log_event_str(" unmatched"); } } return; } if (template_selection == SPECIFIC_VALUE && single_value.n_elements > 0 && get_number_of_permutations() == 0 && single_value.n_elements == match_value.size_of()) { TTCN_Logger::log_event_str("{ "); for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) { if (elem_count > 0) TTCN_Logger::log_event_str(", "); single_value.value_elements[elem_count]->log_match(match_value[elem_count], legacy); } TTCN_Logger::log_event_str(" }"); log_match_length(single_value.n_elements); } else { match_value.log(); TTCN_Logger::log_event_str(" with "); log(); if (match(match_value, legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } } void GTPC__ExtensionHeader__List_template::encode_text(Text_Buf& text_buf) const { encode_text_permutation(text_buf); switch (template_selection) { case SPECIFIC_VALUE: text_buf.push_int(single_value.n_elements); for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) single_value.value_elements[elem_count]->encode_text(text_buf); case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: text_buf.push_int(value_list.n_values); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].encode_text(text_buf); break; default: TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of type @GTPC_Types.GTPC_ExtensionHeader_List."); } } void GTPC__ExtensionHeader__List_template::decode_text(Text_Buf& text_buf) { clean_up(); decode_text_permutation(text_buf); switch (template_selection) { case SPECIFIC_VALUE: single_value.n_elements = text_buf.pull_int().get_val(); if (single_value.n_elements < 0) TTCN_error("Text decoder: Negative size was received for a template of type @GTPC_Types.GTPC_ExtensionHeader_List."); single_value.value_elements = (GTPC__ExtensionHeader_template**)allocate_pointers(single_value.n_elements); for (int elem_count = 0; elem_count < single_value.n_elements; elem_count++) { single_value.value_elements[elem_count] = new GTPC__ExtensionHeader_template; single_value.value_elements[elem_count]->decode_text(text_buf); } case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: value_list.n_values = text_buf.pull_int().get_val(); value_list.list_value = new GTPC__ExtensionHeader__List_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].decode_text(text_buf); break; default: TTCN_error("Text decoder: An unknown/unsupported selection was received for a template of type @GTPC_Types.GTPC_ExtensionHeader_List."); } } boolean GTPC__ExtensionHeader__List_template::is_present(boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE; return !match_omit(legacy); } boolean GTPC__ExtensionHeader__List_template::match_omit(boolean legacy) const { if (is_ifpresent) return TRUE; switch (template_selection) { case OMIT_VALUE: case ANY_OR_OMIT: return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match_omit() || implication_.implied_template->match_omit(); case VALUE_LIST: case COMPLEMENTED_LIST: if (legacy) { for (unsigned int i=0; iget_id()->get_index())].set_param(*param.get_elem(p_i)); } break; case Module_Param::MP_Value_List: { set_size(param.get_size()); int curr_idx = 0; for (size_t p_i=0; p_iget_type()) { case Module_Param::MP_NotUsed: curr_idx++; break; case Module_Param::MP_Permutation_Template: { int perm_start_idx = curr_idx; Module_Param* param_i = param.get_elem(p_i); for (size_t perm_i=0; perm_iget_size(); perm_i++) { (*this)[curr_idx].set_param(*(param_i->get_elem(perm_i))); curr_idx++; } int perm_end_idx = curr_idx - 1; add_permutation(perm_start_idx, perm_end_idx); } break; default: (*this)[curr_idx].set_param(*param.get_elem(p_i)); curr_idx++; } } } break; case Module_Param::MP_Implication_Template: { GTPC__ExtensionHeader__List_template* precondition = new GTPC__ExtensionHeader__List_template; precondition->set_param(*param.get_elem(0)); GTPC__ExtensionHeader__List_template* implied_template = new GTPC__ExtensionHeader__List_template; implied_template->set_param(*param.get_elem(1)); *this = GTPC__ExtensionHeader__List_template(precondition, implied_template); } break; default: param.type_error("record of template", "@GTPC_Types.GTPC_ExtensionHeader_List"); } is_ifpresent = param.get_ifpresent(); set_length_range(param); } void GTPC__ExtensionHeader__List_template::check_restriction(template_res t_res, const char* t_name, boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return; switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) { case TR_OMIT: if (template_selection==OMIT_VALUE) return; case TR_VALUE: if (template_selection!=SPECIFIC_VALUE || is_ifpresent) break; for (int i=0; icheck_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_ExtensionHeader_List"); return; case TR_PRESENT: if (!match_omit(legacy)) return; break; default: return; } TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@GTPC_Types.GTPC_ExtensionHeader_List"); } boolean GTPC__ExtensionHeader__List_template::get_istemplate_kind(const char* type) const { if (!strcmp(type, "AnyElement")) { if (template_selection != SPECIFIC_VALUE) { return FALSE; } for (int i = 0; i < single_value.n_elements; i++) { if (single_value.value_elements[i]->get_selection() == ANY_VALUE) { return TRUE; } } return FALSE; } else if (!strcmp(type, "AnyElementsOrNone")) { if (template_selection != SPECIFIC_VALUE) { return FALSE; } for (int i = 0; i < single_value.n_elements; i++) { if (single_value.value_elements[i]->get_selection() == ANY_OR_OMIT) { return TRUE; } } return FALSE; } else if (!strcmp(type, "permutation")) { return number_of_permutations; } else if (!strcmp(type, "length")) { return length_restriction_type != NO_LENGTH_RESTRICTION; } else { return Base_Template::get_istemplate_kind(type); } } GTPC__ExtensionHeader::GTPC__ExtensionHeader() { } GTPC__ExtensionHeader::GTPC__ExtensionHeader(const INTEGER& par_lengthfield, const OCTETSTRING& par_content, const OCTETSTRING& par_nextExtHeader) : field_lengthfield(par_lengthfield), field_content(par_content), field_nextExtHeader(par_nextExtHeader) { } GTPC__ExtensionHeader::GTPC__ExtensionHeader(const GTPC__ExtensionHeader& other_value) { if(!other_value.is_bound()) TTCN_error("Copying an unbound value of type @GTPC_Types.GTPC_ExtensionHeader."); if (other_value.lengthfield().is_bound()) field_lengthfield = other_value.lengthfield(); else field_lengthfield.clean_up(); if (other_value.content().is_bound()) field_content = other_value.content(); else field_content.clean_up(); if (other_value.nextExtHeader().is_bound()) field_nextExtHeader = other_value.nextExtHeader(); else field_nextExtHeader.clean_up(); } void GTPC__ExtensionHeader::clean_up() { field_lengthfield.clean_up(); field_content.clean_up(); field_nextExtHeader.clean_up(); } const TTCN_Typedescriptor_t* GTPC__ExtensionHeader::get_descriptor() const { return >PC__ExtensionHeader_descr_; } GTPC__ExtensionHeader& GTPC__ExtensionHeader::operator=(const GTPC__ExtensionHeader& other_value) { if (this != &other_value) { if(!other_value.is_bound()) TTCN_error("Assignment of an unbound value of type @GTPC_Types.GTPC_ExtensionHeader."); if (other_value.lengthfield().is_bound()) field_lengthfield = other_value.lengthfield(); else field_lengthfield.clean_up(); if (other_value.content().is_bound()) field_content = other_value.content(); else field_content.clean_up(); if (other_value.nextExtHeader().is_bound()) field_nextExtHeader = other_value.nextExtHeader(); else field_nextExtHeader.clean_up(); } return *this; } boolean GTPC__ExtensionHeader::operator==(const GTPC__ExtensionHeader& other_value) const { return field_lengthfield==other_value.field_lengthfield && field_content==other_value.field_content && field_nextExtHeader==other_value.field_nextExtHeader; } boolean GTPC__ExtensionHeader::is_bound() const { return (field_lengthfield.is_bound()) || (field_content.is_bound()) || (field_nextExtHeader.is_bound()); } boolean GTPC__ExtensionHeader::is_value() const { return field_lengthfield.is_value() && field_content.is_value() && field_nextExtHeader.is_value(); } void GTPC__ExtensionHeader::log() const { if (!is_bound()) { TTCN_Logger::log_event_unbound(); return; } TTCN_Logger::log_event_str("{ lengthfield := "); field_lengthfield.log(); TTCN_Logger::log_event_str(", content := "); field_content.log(); TTCN_Logger::log_event_str(", nextExtHeader := "); field_nextExtHeader.log(); TTCN_Logger::log_event_str(" }"); } void GTPC__ExtensionHeader::set_implicit_omit() { if (lengthfield().is_bound()) lengthfield().set_implicit_omit(); if (content().is_bound()) content().set_implicit_omit(); if (nextExtHeader().is_bound()) nextExtHeader().set_implicit_omit(); } void GTPC__ExtensionHeader::set_param(Module_Param& param) { param.basic_check(Module_Param::BC_VALUE, "record value"); switch (param.get_type()) { case Module_Param::MP_Value_List: if (30 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) lengthfield().set_param(*param.get_elem(0)); if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) content().set_param(*param.get_elem(1)); if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) nextExtHeader().set_param(*param.get_elem(2)); break; case Module_Param::MP_Assignment_List: { Vector value_used(param.get_size()); value_used.resize(param.get_size(), FALSE); for (size_t val_idx=0; val_idxget_id()->get_name(), "lengthfield")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { lengthfield().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "content")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { content().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "nextExtHeader")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { nextExtHeader().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxerror("Non existent field name in type @GTPC_Types.GTPC_ExtensionHeader: %s", curr_param->get_id()->get_name()); break; } } break; default: param.type_error("record value", "@GTPC_Types.GTPC_ExtensionHeader"); } } void GTPC__ExtensionHeader::encode_text(Text_Buf& text_buf) const { field_lengthfield.encode_text(text_buf); field_content.encode_text(text_buf); field_nextExtHeader.encode_text(text_buf); } void GTPC__ExtensionHeader::decode_text(Text_Buf& text_buf) { field_lengthfield.decode_text(text_buf); field_content.decode_text(text_buf); field_nextExtHeader.decode_text(text_buf); } void GTPC__ExtensionHeader::encode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) const { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-encoding type '%s': ", p_td.name); unsigned BER_coding=va_arg(pvar, unsigned); BER_encode_chk_coding(BER_coding); ASN_BER_TLV_t *tlv=BER_encode_TLV(p_td, BER_coding); tlv->put_in_buffer(p_buf); ASN_BER_TLV_t::destruct(tlv); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-encoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); RAW_enc_tr_pos rp; rp.level=0; rp.pos=NULL; RAW_enc_tree root(FALSE, NULL, &rp, 1, p_td.raw); RAW_encode(p_td, root); root.put_to_buf(p_buf); break;} case TTCN_EncDec::CT_TEXT: { TTCN_EncDec_ErrorContext ec("While TEXT-encoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); TEXT_encode(p_td,p_buf); break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-encoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XER_encode(*(p_td.xer),p_buf, XER_coding, 0, 0, 0); p_buf.put_c('\n'); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-encoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok(va_arg(pvar, int) != 0); JSON_encode(p_td, tok, FALSE); p_buf.put_s(tok.get_buffer_length(), (const unsigned char*)tok.get_buffer()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-encoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_encode(p_td, p_buf); break;} default: TTCN_error("Unknown coding method requested to encode type '%s'", p_td.name); } va_end(pvar); } void GTPC__ExtensionHeader::decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int p_coding, ...) { va_list pvar; va_start(pvar, p_coding); switch(p_coding) { case TTCN_EncDec::CT_BER: { TTCN_EncDec_ErrorContext ec("While BER-decoding type '%s': ", p_td.name); unsigned L_form=va_arg(pvar, unsigned); ASN_BER_TLV_t tlv; BER_decode_str2TLV(p_buf, tlv, L_form); BER_decode_TLV(p_td, tlv, L_form); if(tlv.isComplete) p_buf.increase_pos(tlv.get_len()); break;} case TTCN_EncDec::CT_RAW: { TTCN_EncDec_ErrorContext ec("While RAW-decoding type '%s': ", p_td.name); if(!p_td.raw) TTCN_EncDec_ErrorContext::error_internal ("No RAW descriptor available for type '%s'.", p_td.name); raw_order_t r_order; switch(p_td.raw->top_bit_order) { case TOP_BIT_LEFT: r_order=ORDER_LSB; break; case TOP_BIT_RIGHT: default: r_order=ORDER_MSB; } int rawr = RAW_decode(p_td, p_buf, p_buf.get_len()*8, r_order); if(rawr<0) switch (-rawr) { case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: ec.error((TTCN_EncDec::error_type_t)-rawr, "Can not decode type '%s', because incomplete message was received", p_td.name); break; case 1: default: ec.error(TTCN_EncDec::ET_INVAL_MSG, "Can not decode type '%s', because invalid message was received", p_td.name); break; } break;} case TTCN_EncDec::CT_TEXT: { Limit_Token_List limit; TTCN_EncDec_ErrorContext ec("While TEXT-decoding type '%s': ", p_td.name); if(!p_td.text) TTCN_EncDec_ErrorContext::error_internal ("No TEXT descriptor available for type '%s'.", p_td.name); const unsigned char *b_data=p_buf.get_data(); int null_added=0; if(b_data[p_buf.get_len()-1]!='\0'){ null_added=1; p_buf.set_pos(p_buf.get_len()); p_buf.put_zero(8,ORDER_LSB); p_buf.rewind(); } if(TEXT_decode(p_td,p_buf,limit)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); if(null_added){ size_t actpos=p_buf.get_pos(); p_buf.set_pos(p_buf.get_len()-1); p_buf.cut_end(); p_buf.set_pos(actpos); } break;} case TTCN_EncDec::CT_XER: { TTCN_EncDec_ErrorContext ec("While XER-decoding type '%s': ", p_td.name); unsigned XER_coding=va_arg(pvar, unsigned); XER_encode_chk_coding(XER_coding, p_td); XmlReaderWrap reader(p_buf); for (int rd_ok=reader.Read(); rd_ok==1; rd_ok=reader.Read()) { if (reader.NodeType() == XML_READER_TYPE_ELEMENT) break; } XER_decode(*(p_td.xer), reader, XER_coding | XER_TOPLEVEL, XER_NONE, 0); size_t bytes = reader.ByteConsumed(); p_buf.set_pos(bytes); break;} case TTCN_EncDec::CT_JSON: { TTCN_EncDec_ErrorContext ec("While JSON-decoding type '%s': ", p_td.name); if(!p_td.json) TTCN_EncDec_ErrorContext::error_internal ("No JSON descriptor available for type '%s'.", p_td.name); JSON_Tokenizer tok((const char*)p_buf.get_data(), p_buf.get_len()); if(JSON_decode(p_td, tok, FALSE, FALSE)<0) ec.error(TTCN_EncDec::ET_INCOMPL_MSG,"Can not decode type '%s', because invalid or incomplete message was received", p_td.name); p_buf.set_pos(tok.get_buf_pos()); break;} case TTCN_EncDec::CT_OER: { TTCN_EncDec_ErrorContext ec("While OER-decoding type '%s': ", p_td.name); if(!p_td.oer) TTCN_EncDec_ErrorContext::error_internal ("No OER descriptor available for type '%s'.", p_td.name); OER_struct p_oer; OER_decode(p_td, p_buf, p_oer); break;} default: TTCN_error("Unknown coding method requested to decode type '%s'", p_td.name); } va_end(pvar); } int GTPC__ExtensionHeader::RAW_decode(const TTCN_Typedescriptor_t& p_td, TTCN_Buffer& p_buf, int limit, raw_order_t top_bit_ord, boolean no_err, int, boolean, const RAW_Force_Omit* force_omit) { (void)no_err; int prepaddlength=p_buf.increase_pos_padd(p_td.raw->prepadding); limit-=prepaddlength; size_t last_decoded_pos = p_buf.get_pos_bit(); int decoded_length = 0; int decoded_field_length = 0; raw_order_t local_top_order; if(p_td.raw->top_bit_order==TOP_BIT_INHERITED)local_top_order=top_bit_ord; else if(p_td.raw->top_bit_order==TOP_BIT_RIGHT)local_top_order=ORDER_MSB; else local_top_order=ORDER_LSB; int value_of_length_field0 = 0; RAW_Force_Omit field_0_force_omit(0, force_omit, GTPC__ExtensionHeader_lengthfield_descr_.raw->forceomit); decoded_field_length = field_lengthfield.RAW_decode(GTPC__ExtensionHeader_lengthfield_descr_, p_buf, limit, local_top_order, no_err, -1, TRUE, &field_0_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); INTEGER tmp0 = field_lengthfield.convert_to_Integer(GTPC__ExtensionHeader_lengthfield_descr_); field_lengthfield = tmp0; value_of_length_field0 += tmp0.get_long_long_val() * 32; value_of_length_field0 -= decoded_field_length; if (value_of_length_field0 < 0) return -1; RAW_Force_Omit field_1_force_omit(1, force_omit, OCTETSTRING_descr_.raw->forceomit); decoded_field_length = field_content.RAW_decode(OCTETSTRING_descr_, p_buf, min_of_ints(2, limit, value_of_length_field0), local_top_order, no_err, -1, TRUE, &field_1_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); value_of_length_field0 -= decoded_field_length; RAW_Force_Omit field_2_force_omit(2, force_omit, GTPC__ExtensionHeader_nextExtHeader_descr_.raw->forceomit); decoded_field_length = field_nextExtHeader.RAW_decode(GTPC__ExtensionHeader_nextExtHeader_descr_, p_buf, min_of_ints(2, limit, value_of_length_field0), local_top_order, no_err, -1, TRUE, &field_2_force_omit); if (decoded_field_length < 0) return decoded_field_length; decoded_length+=decoded_field_length; limit-=decoded_field_length; last_decoded_pos=bigger(last_decoded_pos, p_buf.get_pos_bit()); value_of_length_field0 -= decoded_field_length; p_buf.set_pos_bit(last_decoded_pos); return decoded_length+prepaddlength+p_buf.increase_pos_padd(p_td.raw->padding); } int GTPC__ExtensionHeader::RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree& myleaf) const { if (!is_bound()) TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_UNBOUND, "Encoding an unbound value."); int encoded_length = 0; myleaf.isleaf = FALSE; myleaf.body.node.num_of_nodes = 3; myleaf.body.node.nodes = init_nodes_of_enc_tree(3); myleaf.body.node.nodes[0] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 0, GTPC__ExtensionHeader_lengthfield_descr_.raw); myleaf.body.node.nodes[1] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 1, OCTETSTRING_descr_.raw); myleaf.body.node.nodes[2] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 2, GTPC__ExtensionHeader_nextExtHeader_descr_.raw); encoded_length += 8; myleaf.body.node.nodes[0]->calc = CALC_LENGTH; myleaf.body.node.nodes[0]->coding_descr = >PC__ExtensionHeader_lengthfield_descr_; myleaf.body.node.nodes[0]->calcof.lengthto.num_of_fields = 3; myleaf.body.node.nodes[0]->calcof.lengthto.unit = 32; myleaf.body.node.nodes[0]->calcof.lengthto.offset = 0; myleaf.body.node.nodes[0]->calcof.lengthto.fields = init_lengthto_fields_list(3); myleaf.body.node.nodes[0]->length = 8; myleaf.body.node.nodes[0]->calcof.lengthto.fields[0].level = myleaf.body.node.nodes[0]->curr_pos.level; myleaf.body.node.nodes[0]->calcof.lengthto.fields[0].pos = myleaf.body.node.nodes[0]->curr_pos.pos; myleaf.body.node.nodes[0]->calcof.lengthto.fields[1].level = myleaf.body.node.nodes[1]->curr_pos.level; myleaf.body.node.nodes[0]->calcof.lengthto.fields[1].pos = myleaf.body.node.nodes[1]->curr_pos.pos; myleaf.body.node.nodes[0]->calcof.lengthto.fields[2].level = myleaf.body.node.nodes[2]->curr_pos.level; myleaf.body.node.nodes[0]->calcof.lengthto.fields[2].pos = myleaf.body.node.nodes[2]->curr_pos.pos; encoded_length += field_content.RAW_encode(OCTETSTRING_descr_, *myleaf.body.node.nodes[1]); encoded_length += field_nextExtHeader.RAW_encode(GTPC__ExtensionHeader_nextExtHeader_descr_, *myleaf.body.node.nodes[2]); return myleaf.length = encoded_length; } struct GTPC__ExtensionHeader_template::single_value_struct { INTEGER_template field_lengthfield; OCTETSTRING_template field_content; OCTETSTRING_template field_nextExtHeader; }; void GTPC__ExtensionHeader_template::set_specific() { if (template_selection != SPECIFIC_VALUE) { template_sel old_selection = template_selection; clean_up(); single_value = new single_value_struct; set_selection(SPECIFIC_VALUE); if (old_selection == ANY_VALUE || old_selection == ANY_OR_OMIT) { single_value->field_lengthfield = ANY_VALUE; single_value->field_content = ANY_VALUE; single_value->field_nextExtHeader = ANY_VALUE; } } } void GTPC__ExtensionHeader_template::copy_value(const GTPC__ExtensionHeader& other_value) { single_value = new single_value_struct; if (other_value.lengthfield().is_bound()) { single_value->field_lengthfield = other_value.lengthfield(); } else { single_value->field_lengthfield.clean_up(); } if (other_value.content().is_bound()) { single_value->field_content = other_value.content(); } else { single_value->field_content.clean_up(); } if (other_value.nextExtHeader().is_bound()) { single_value->field_nextExtHeader = other_value.nextExtHeader(); } else { single_value->field_nextExtHeader.clean_up(); } set_selection(SPECIFIC_VALUE); } void GTPC__ExtensionHeader_template::copy_template(const GTPC__ExtensionHeader_template& other_value) { switch (other_value.template_selection) { case SPECIFIC_VALUE: single_value = new single_value_struct; if (UNINITIALIZED_TEMPLATE != other_value.lengthfield().get_selection()) { single_value->field_lengthfield = other_value.lengthfield(); } else { single_value->field_lengthfield.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.content().get_selection()) { single_value->field_content = other_value.content(); } else { single_value->field_content.clean_up(); } if (UNINITIALIZED_TEMPLATE != other_value.nextExtHeader().get_selection()) { single_value->field_nextExtHeader = other_value.nextExtHeader(); } else { single_value->field_nextExtHeader.clean_up(); } case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: value_list.n_values = other_value.value_list.n_values; value_list.list_value = new GTPC__ExtensionHeader_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].copy_template(other_value.value_list.list_value[list_count]); break; case IMPLICATION_MATCH: implication_.precondition = new GTPC__ExtensionHeader_template(*other_value.implication_.precondition); implication_.implied_template = new GTPC__ExtensionHeader_template(*other_value.implication_.implied_template); break; case DYNAMIC_MATCH: dyn_match = other_value.dyn_match; dyn_match->ref_count++; break; default: TTCN_error("Copying an uninitialized/unsupported template of type @GTPC_Types.GTPC_ExtensionHeader."); break; } set_selection(other_value); } GTPC__ExtensionHeader_template::GTPC__ExtensionHeader_template() { } GTPC__ExtensionHeader_template::GTPC__ExtensionHeader_template(template_sel other_value) : Base_Template(other_value) { check_single_selection(other_value); } GTPC__ExtensionHeader_template::GTPC__ExtensionHeader_template(const GTPC__ExtensionHeader& other_value) { copy_value(other_value); } GTPC__ExtensionHeader_template::GTPC__ExtensionHeader_template(const OPTIONAL& other_value) { switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const GTPC__ExtensionHeader&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Creating a template of type @GTPC_Types.GTPC_ExtensionHeader from an unbound optional field."); } } GTPC__ExtensionHeader_template::GTPC__ExtensionHeader_template(GTPC__ExtensionHeader_template* p_precondition, GTPC__ExtensionHeader_template* p_implied_template) : Base_Template(IMPLICATION_MATCH) { implication_.precondition = p_precondition; implication_.implied_template = p_implied_template; } GTPC__ExtensionHeader_template::GTPC__ExtensionHeader_template(Dynamic_Match_Interface* p_dyn_match) : Base_Template(DYNAMIC_MATCH) { dyn_match = new dynmatch_struct; dyn_match->ptr = p_dyn_match; dyn_match->ref_count = 1; } GTPC__ExtensionHeader_template::GTPC__ExtensionHeader_template(const GTPC__ExtensionHeader_template& other_value) : Base_Template() { copy_template(other_value); } GTPC__ExtensionHeader_template::~GTPC__ExtensionHeader_template() { clean_up(); } GTPC__ExtensionHeader_template& GTPC__ExtensionHeader_template::operator=(template_sel other_value) { check_single_selection(other_value); clean_up(); set_selection(other_value); return *this; } GTPC__ExtensionHeader_template& GTPC__ExtensionHeader_template::operator=(const GTPC__ExtensionHeader& other_value) { clean_up(); copy_value(other_value); return *this; } GTPC__ExtensionHeader_template& GTPC__ExtensionHeader_template::operator=(const OPTIONAL& other_value) { clean_up(); switch (other_value.get_selection()) { case OPTIONAL_PRESENT: copy_value((const GTPC__ExtensionHeader&)other_value); break; case OPTIONAL_OMIT: set_selection(OMIT_VALUE); break; default: TTCN_error("Assignment of an unbound optional field to a template of type @GTPC_Types.GTPC_ExtensionHeader."); } return *this; } GTPC__ExtensionHeader_template& GTPC__ExtensionHeader_template::operator=(const GTPC__ExtensionHeader_template& other_value) { if (&other_value != this) { clean_up(); copy_template(other_value); } return *this; } boolean GTPC__ExtensionHeader_template::match(const GTPC__ExtensionHeader& other_value, boolean legacy) const { if (!other_value.is_bound()) return FALSE; switch (template_selection) { case ANY_VALUE: case ANY_OR_OMIT: return TRUE; case OMIT_VALUE: return FALSE; case SPECIFIC_VALUE: if(!other_value.lengthfield().is_bound()) return FALSE; if(!single_value->field_lengthfield.match(other_value.lengthfield(), legacy))return FALSE; if(!other_value.content().is_bound()) return FALSE; if(!single_value->field_content.match(other_value.content(), legacy))return FALSE; if(!other_value.nextExtHeader().is_bound()) return FALSE; if(!single_value->field_nextExtHeader.match(other_value.nextExtHeader(), legacy))return FALSE; return TRUE; case VALUE_LIST: case COMPLEMENTED_LIST: for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) if (value_list.list_value[list_count].match(other_value, legacy)) return template_selection == VALUE_LIST; return template_selection == COMPLEMENTED_LIST; case CONJUNCTION_MATCH: for (unsigned int i = 0; i < value_list.n_values; i++) { if (!value_list.list_value[i].match(other_value)) { return FALSE; } } return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match(other_value) || implication_.implied_template->match(other_value); case DYNAMIC_MATCH: return dyn_match->ptr->match(other_value); default: TTCN_error("Matching an uninitialized/unsupported template of type @GTPC_Types.GTPC_ExtensionHeader."); } return FALSE; } boolean GTPC__ExtensionHeader_template::is_bound() const { if (template_selection == UNINITIALIZED_TEMPLATE && !is_ifpresent) return FALSE; if (template_selection != SPECIFIC_VALUE) return TRUE; return single_value->field_lengthfield.is_bound() || single_value->field_content.is_bound() || single_value->field_nextExtHeader.is_bound(); } boolean GTPC__ExtensionHeader_template::is_value() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE; return single_value->field_lengthfield.is_value() && single_value->field_content.is_value() && single_value->field_nextExtHeader.is_value(); } void GTPC__ExtensionHeader_template::clean_up() { switch (template_selection) { case SPECIFIC_VALUE: delete single_value; break; case VALUE_LIST: case COMPLEMENTED_LIST: case CONJUNCTION_MATCH: delete [] value_list.list_value; break; case IMPLICATION_MATCH: delete implication_.precondition; delete implication_.implied_template; break; case DYNAMIC_MATCH: dyn_match->ref_count--; if (dyn_match->ref_count == 0) { delete dyn_match->ptr; delete dyn_match; } break; default: break; } template_selection = UNINITIALIZED_TEMPLATE; } GTPC__ExtensionHeader GTPC__ExtensionHeader_template::valueof() const { if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of type @GTPC_Types.GTPC_ExtensionHeader."); GTPC__ExtensionHeader ret_val; if (single_value->field_lengthfield.is_bound()) { ret_val.lengthfield() = single_value->field_lengthfield.valueof(); } if (single_value->field_content.is_bound()) { ret_val.content() = single_value->field_content.valueof(); } if (single_value->field_nextExtHeader.is_bound()) { ret_val.nextExtHeader() = single_value->field_nextExtHeader.valueof(); } return ret_val; } void GTPC__ExtensionHeader_template::set_type(template_sel template_type, unsigned int list_length) { if (template_type != VALUE_LIST && template_type != COMPLEMENTED_LIST&& template_type != CONJUNCTION_MATCH) TTCN_error("Setting an invalid list for a template of type @GTPC_Types.GTPC_ExtensionHeader."); clean_up(); set_selection(template_type); value_list.n_values = list_length; value_list.list_value = new GTPC__ExtensionHeader_template[list_length]; } GTPC__ExtensionHeader_template& GTPC__ExtensionHeader_template::list_item(unsigned int list_index) const { if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST&& template_selection != CONJUNCTION_MATCH) TTCN_error("Accessing a list element of a non-list template of type @GTPC_Types.GTPC_ExtensionHeader."); if (list_index >= value_list.n_values) TTCN_error("Index overflow in a value list template of type @GTPC_Types.GTPC_ExtensionHeader."); return value_list.list_value[list_index]; } INTEGER_template& GTPC__ExtensionHeader_template::lengthfield() { set_specific(); return single_value->field_lengthfield; } const INTEGER_template& GTPC__ExtensionHeader_template::lengthfield() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field lengthfield of a non-specific template of type @GTPC_Types.GTPC_ExtensionHeader."); return single_value->field_lengthfield; } OCTETSTRING_template& GTPC__ExtensionHeader_template::content() { set_specific(); return single_value->field_content; } const OCTETSTRING_template& GTPC__ExtensionHeader_template::content() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field content of a non-specific template of type @GTPC_Types.GTPC_ExtensionHeader."); return single_value->field_content; } OCTETSTRING_template& GTPC__ExtensionHeader_template::nextExtHeader() { set_specific(); return single_value->field_nextExtHeader; } const OCTETSTRING_template& GTPC__ExtensionHeader_template::nextExtHeader() const { if (template_selection != SPECIFIC_VALUE) TTCN_error("Accessing field nextExtHeader of a non-specific template of type @GTPC_Types.GTPC_ExtensionHeader."); return single_value->field_nextExtHeader; } int GTPC__ExtensionHeader_template::size_of() const { if (is_ifpresent) TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader which has an ifpresent attribute."); switch (template_selection) { case SPECIFIC_VALUE: return 3; case VALUE_LIST: { if (value_list.n_values<1) TTCN_error("Internal error: Performing sizeof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader containing an empty list."); int item_size = value_list.list_value[0].size_of(); for (unsigned int l_idx = 1; l_idx < value_list.n_values; l_idx++) { if (value_list.list_value[l_idx].size_of()!=item_size) TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader containing a value list with different sizes."); } return item_size; } case OMIT_VALUE: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader containing omit value."); case ANY_VALUE: case ANY_OR_OMIT: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader containing */? value."); case COMPLEMENTED_LIST: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader containing complemented list."); case CONJUNCTION_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader containing a conjunction list match."); case IMPLICATION_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader containing an implication match."); case DYNAMIC_MATCH: TTCN_error("Performing sizeof() operation on a template of type @GTPC_Types.GTPC_ExtensionHeader containing a dynamic match."); default: TTCN_error("Performing sizeof() operation on an uninitialized/unsupported template of type @GTPC_Types.GTPC_ExtensionHeader."); } return 0; } void GTPC__ExtensionHeader_template::log() const { switch (template_selection) { case SPECIFIC_VALUE: TTCN_Logger::log_event_str("{ lengthfield := "); single_value->field_lengthfield.log(); TTCN_Logger::log_event_str(", content := "); single_value->field_content.log(); TTCN_Logger::log_event_str(", nextExtHeader := "); single_value->field_nextExtHeader.log(); TTCN_Logger::log_event_str(" }"); break; case COMPLEMENTED_LIST: TTCN_Logger::log_event_str("complement"); case CONJUNCTION_MATCH: if (template_selection == CONJUNCTION_MATCH) { TTCN_Logger::log_event_str("conjunct"); } case VALUE_LIST: TTCN_Logger::log_char('('); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) { if (list_count > 0) TTCN_Logger::log_event_str(", "); value_list.list_value[list_count].log(); } TTCN_Logger::log_char(')'); break; case IMPLICATION_MATCH: implication_.precondition->log(); TTCN_Logger::log_event_str(" implies "); implication_.implied_template->log(); break; case DYNAMIC_MATCH: TTCN_Logger::log_event_str("@dynamic template"); break; default: log_generic(); } log_ifpresent(); } void GTPC__ExtensionHeader_template::log_match(const GTPC__ExtensionHeader& match_value, boolean legacy) const { if(TTCN_Logger::VERBOSITY_COMPACT == TTCN_Logger::get_matching_verbosity()){ if(match(match_value, legacy)){ TTCN_Logger::print_logmatch_buffer(); TTCN_Logger::log_event_str(" matched"); } else{ if (template_selection == SPECIFIC_VALUE) { size_t previous_size = TTCN_Logger::get_logmatch_buffer_len(); if(!single_value->field_lengthfield.match(match_value.lengthfield(), legacy)){ TTCN_Logger::log_logmatch_info(".lengthfield"); single_value->field_lengthfield.log_match(match_value.lengthfield(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_content.match(match_value.content(), legacy)){ TTCN_Logger::log_logmatch_info(".content"); single_value->field_content.log_match(match_value.content(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } if(!single_value->field_nextExtHeader.match(match_value.nextExtHeader(), legacy)){ TTCN_Logger::log_logmatch_info(".nextExtHeader"); single_value->field_nextExtHeader.log_match(match_value.nextExtHeader(), legacy); TTCN_Logger::set_logmatch_buffer_len(previous_size); } }else { TTCN_Logger::print_logmatch_buffer(); match_value.log(); TTCN_Logger::log_event_str(" with "); log(); TTCN_Logger::log_event_str(" unmatched"); } } return; } if (template_selection == SPECIFIC_VALUE) { TTCN_Logger::log_event_str("{ lengthfield := "); single_value->field_lengthfield.log_match(match_value.lengthfield(), legacy); TTCN_Logger::log_event_str(", content := "); single_value->field_content.log_match(match_value.content(), legacy); TTCN_Logger::log_event_str(", nextExtHeader := "); single_value->field_nextExtHeader.log_match(match_value.nextExtHeader(), legacy); TTCN_Logger::log_event_str(" }"); } else { match_value.log(); TTCN_Logger::log_event_str(" with "); log(); if (match(match_value, legacy)) TTCN_Logger::log_event_str(" matched"); else TTCN_Logger::log_event_str(" unmatched"); } } void GTPC__ExtensionHeader_template::encode_text(Text_Buf& text_buf) const { encode_text_base(text_buf); switch (template_selection) { case SPECIFIC_VALUE: single_value->field_lengthfield.encode_text(text_buf); single_value->field_content.encode_text(text_buf); single_value->field_nextExtHeader.encode_text(text_buf); case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: text_buf.push_int(value_list.n_values); for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].encode_text(text_buf); break; default: TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of type @GTPC_Types.GTPC_ExtensionHeader."); } } void GTPC__ExtensionHeader_template::decode_text(Text_Buf& text_buf) { clean_up(); decode_text_base(text_buf); switch (template_selection) { case SPECIFIC_VALUE: single_value = new single_value_struct; single_value->field_lengthfield.decode_text(text_buf); single_value->field_content.decode_text(text_buf); single_value->field_nextExtHeader.decode_text(text_buf); case OMIT_VALUE: case ANY_VALUE: case ANY_OR_OMIT: break; case VALUE_LIST: case COMPLEMENTED_LIST: value_list.n_values = text_buf.pull_int().get_val(); value_list.list_value = new GTPC__ExtensionHeader_template[value_list.n_values]; for (unsigned int list_count = 0; list_count < value_list.n_values; list_count++) value_list.list_value[list_count].decode_text(text_buf); break; default: TTCN_error("Text decoder: An unknown/unsupported selection was received in a template of type @GTPC_Types.GTPC_ExtensionHeader."); } } void GTPC__ExtensionHeader_template::set_param(Module_Param& param) { param.basic_check(Module_Param::BC_TEMPLATE, "record template"); switch (param.get_type()) { case Module_Param::MP_Omit: *this = OMIT_VALUE; break; case Module_Param::MP_Any: *this = ANY_VALUE; break; case Module_Param::MP_AnyOrNone: *this = ANY_OR_OMIT; break; case Module_Param::MP_List_Template: case Module_Param::MP_ComplementList_Template: case Module_Param::MP_ConjunctList_Template: { GTPC__ExtensionHeader_template new_temp; new_temp.set_type(param.get_type()==Module_Param::MP_List_Template ? VALUE_LIST : (param.get_type() == Module_Param::MP_ConjunctList_Template ? CONJUNCTION_MATCH : COMPLEMENTED_LIST), param.get_size()); for (size_t p_i=0; p_i0 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) lengthfield().set_param(*param.get_elem(0)); if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) content().set_param(*param.get_elem(1)); if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) nextExtHeader().set_param(*param.get_elem(2)); break; case Module_Param::MP_Assignment_List: { Vector value_used(param.get_size()); value_used.resize(param.get_size(), FALSE); for (size_t val_idx=0; val_idxget_id()->get_name(), "lengthfield")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { lengthfield().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "content")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { content().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxget_id()->get_name(), "nextExtHeader")) { if (curr_param->get_type()!=Module_Param::MP_NotUsed) { nextExtHeader().set_param(*curr_param); } value_used[val_idx]=TRUE; } } for (size_t val_idx=0; val_idxerror("Non existent field name in type @GTPC_Types.GTPC_ExtensionHeader: %s", curr_param->get_id()->get_name()); break; } } break; case Module_Param::MP_Implication_Template: { GTPC__ExtensionHeader_template* precondition = new GTPC__ExtensionHeader_template; precondition->set_param(*param.get_elem(0)); GTPC__ExtensionHeader_template* implied_template = new GTPC__ExtensionHeader_template; implied_template->set_param(*param.get_elem(1)); *this = GTPC__ExtensionHeader_template(precondition, implied_template); } break; default: param.type_error("record template", "@GTPC_Types.GTPC_ExtensionHeader"); } is_ifpresent = param.get_ifpresent(); } void GTPC__ExtensionHeader_template::check_restriction(template_res t_res, const char* t_name, boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return; switch ((t_name&&(t_res==TR_VALUE))?TR_OMIT:t_res) { case TR_OMIT: if (template_selection==OMIT_VALUE) return; case TR_VALUE: if (template_selection!=SPECIFIC_VALUE || is_ifpresent) break; single_value->field_lengthfield.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_ExtensionHeader"); single_value->field_content.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_ExtensionHeader"); single_value->field_nextExtHeader.check_restriction(t_res, t_name ? t_name : "@GTPC_Types.GTPC_ExtensionHeader"); return; case TR_PRESENT: if (!match_omit(legacy)) return; break; default: return; } TTCN_error("Restriction `%s' on template of type %s violated.", get_res_name(t_res), t_name ? t_name : "@GTPC_Types.GTPC_ExtensionHeader"); } boolean GTPC__ExtensionHeader_template::is_present(boolean legacy) const { if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE; return !match_omit(legacy); } boolean GTPC__ExtensionHeader_template::match_omit(boolean legacy) const { if (is_ifpresent) return TRUE; switch (template_selection) { case OMIT_VALUE: case ANY_OR_OMIT: return TRUE; case IMPLICATION_MATCH: return !implication_.precondition->match_omit() || implication_.implied_template->match_omit(); case VALUE_LIST: case COMPLEMENTED_LIST: if (legacy) { for (unsigned int l_idx=0; l_idxn_elements == 0; } void AuthenticationTriplet__GTPC__SetOf_encoder(const AuthenticationTriplet__GTPC__SetOf& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AuthenticationTriplet_GTPC_SetOf' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AuthenticationTriplet__GTPC__SetOf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AuthenticationTriplet__GTPC__SetOf_decoder(OCTETSTRING& input_stream, AuthenticationTriplet__GTPC__SetOf& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AuthenticationTriplet_GTPC_SetOf' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AuthenticationTriplet__GTPC__SetOf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MAP__Cause_encoder(const MAP__Cause& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MAP_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MAP__Cause_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MAP__Cause_decoder(OCTETSTRING& input_stream, MAP__Cause& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MAP_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MAP__Cause_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PTMSI__Signature_encoder(const PTMSI__Signature& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PTMSI_Signature' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PTMSI__Signature_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PTMSI__Signature_decoder(OCTETSTRING& input_stream, PTMSI__Signature& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PTMSI_Signature' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PTMSI__Signature_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MS__Validated_encoder(const MS__Validated& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MS_Validated' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MS__Validated_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MS__Validated_decoder(OCTETSTRING& input_stream, MS__Validated& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MS_Validated' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MS__Validated_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Recovery__gtpc_encoder(const Recovery__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Recovery_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Recovery__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Recovery__gtpc_decoder(OCTETSTRING& input_stream, Recovery__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Recovery_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Recovery__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SelectionMode_encoder(const SelectionMode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SelectionMode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SelectionMode_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SelectionMode_decoder(OCTETSTRING& input_stream, SelectionMode& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SelectionMode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SelectionMode_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TeidDataI_encoder(const TeidDataI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TeidDataI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TeidDataI_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TeidDataI_decoder(OCTETSTRING& input_stream, TeidDataI& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TeidDataI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TeidDataI_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TeidControlPlane_encoder(const TeidControlPlane& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TeidControlPlane' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TeidControlPlane_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TeidControlPlane_decoder(OCTETSTRING& input_stream, TeidControlPlane& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TeidControlPlane' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TeidControlPlane_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const TeidDataII__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.TeidDataII_List."); return other_value.val_ptr->n_elements == 0; } void TeidDataII_encoder(const TeidDataII& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TeidDataII' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TeidDataII_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TeidDataII_decoder(OCTETSTRING& input_stream, TeidDataII& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TeidDataII' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TeidDataII_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TeidDataII__List_encoder(const TeidDataII__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TeidDataII_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TeidDataII__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TeidDataII__List_decoder(OCTETSTRING& input_stream, TeidDataII__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TeidDataII_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TeidDataII__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TearDownInd_encoder(const TearDownInd& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TearDownInd' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TearDownInd_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TearDownInd_decoder(OCTETSTRING& input_stream, TearDownInd& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TearDownInd' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TearDownInd_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void NSAPI__GTPC_encoder(const NSAPI__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.NSAPI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(NSAPI__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER NSAPI__GTPC_decoder(OCTETSTRING& input_stream, NSAPI__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.NSAPI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(NSAPI__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RANAPCause_encoder(const RANAPCause& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RANAPCause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RANAPCause_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RANAPCause_decoder(OCTETSTRING& input_stream, RANAPCause& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RANAPCause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RANAPCause_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const RABContext__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.RABContext_List."); return other_value.val_ptr->n_elements == 0; } void RABContext_encoder(const RABContext& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RABContext' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RABContext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RABContext_decoder(OCTETSTRING& input_stream, RABContext& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RABContext' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RABContext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RABContext__List_encoder(const RABContext__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RABContext_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RABContext__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RABContext__List_decoder(OCTETSTRING& input_stream, RABContext__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RABContext_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RABContext__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RadioPrioritySMS_encoder(const RadioPrioritySMS& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RadioPrioritySMS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RadioPrioritySMS_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RadioPrioritySMS_decoder(OCTETSTRING& input_stream, RadioPrioritySMS& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RadioPrioritySMS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RadioPrioritySMS_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const RadioPriority__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.RadioPriority_List."); return other_value.val_ptr->n_elements == 0; } void RadioPriority_encoder(const RadioPriority& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RadioPriority' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RadioPriority_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RadioPriority_decoder(OCTETSTRING& input_stream, RadioPriority& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RadioPriority' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RadioPriority_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RadioPriority__List_encoder(const RadioPriority__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RadioPriority_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RadioPriority__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RadioPriority__List_decoder(OCTETSTRING& input_stream, RadioPriority__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RadioPriority_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RadioPriority__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const PacketFlowID__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.PacketFlowID_List."); return other_value.val_ptr->n_elements == 0; } void PacketFlowID_encoder(const PacketFlowID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PacketFlowID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PacketFlowID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PacketFlowID_decoder(OCTETSTRING& input_stream, PacketFlowID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PacketFlowID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PacketFlowID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PacketFlowID__List_encoder(const PacketFlowID__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PacketFlowID_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PacketFlowID__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PacketFlowID__List_decoder(OCTETSTRING& input_stream, PacketFlowID__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PacketFlowID_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PacketFlowID__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const ChargingCharacteristics__List__GTPC& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.ChargingCharacteristics_List_GTPC."); return other_value.val_ptr->n_elements == 0; } void ChargingCharacteristics__GTPC_encoder(const ChargingCharacteristics__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ChargingCharacteristics_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ChargingCharacteristics__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ChargingCharacteristics__GTPC_decoder(OCTETSTRING& input_stream, ChargingCharacteristics__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ChargingCharacteristics_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ChargingCharacteristics__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ChargingCharacteristics__List__GTPC_encoder(const ChargingCharacteristics__List__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ChargingCharacteristics_List_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ChargingCharacteristics__List__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ChargingCharacteristics__List__GTPC_decoder(OCTETSTRING& input_stream, ChargingCharacteristics__List__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ChargingCharacteristics_List_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ChargingCharacteristics__List__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TraceRef_encoder(const TraceRef& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TraceRef' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TraceRef_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TraceRef_decoder(OCTETSTRING& input_stream, TraceRef& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TraceRef' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TraceRef_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTP__TraceType_encoder(const GTP__TraceType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTP_TraceType' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GTP__TraceType_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTP__TraceType_decoder(OCTETSTRING& input_stream, GTP__TraceType& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTP_TraceType' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GTP__TraceType_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MSNotReachableReason_encoder(const MSNotReachableReason& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MSNotReachableReason' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MSNotReachableReason_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MSNotReachableReason_decoder(OCTETSTRING& input_stream, MSNotReachableReason& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MSNotReachableReason' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MSNotReachableReason_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RadioPriorityLCS_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RadioPriorityLCS_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RadioPriorityLCS_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RadioPriorityLCS_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RadioPriorityLCS_encoder(const RadioPriorityLCS& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RadioPriorityLCS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RadioPriorityLCS_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RadioPriorityLCS_decoder(OCTETSTRING& input_stream, RadioPriorityLCS& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RadioPriorityLCS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RadioPriorityLCS_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ChargingID_encoder(const ChargingID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ChargingID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ChargingID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ChargingID_decoder(OCTETSTRING& input_stream, ChargingID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ChargingID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ChargingID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressIPv4_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressIPv4_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressIPv4_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressIPv4_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressIPv4_encoder(const EndUserAddressIPv4& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddressIPv4' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressIPv4_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressIPv4_decoder(OCTETSTRING& input_stream, EndUserAddressIPv4& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddressIPv4' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressIPv4_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressIPv6_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressIPv6_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressIPv6_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressIPv6_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressIPv6_encoder(const EndUserAddressIPv6& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddressIPv6' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressIPv6_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressIPv6_decoder(OCTETSTRING& input_stream, EndUserAddressIPv6& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddressIPv6' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressIPv6_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressPPP_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressPPP_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressPPP_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressPPP_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressPPP_encoder(const EndUserAddressPPP& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddressPPP' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressPPP_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressPPP_decoder(OCTETSTRING& input_stream, EndUserAddressPPP& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddressPPP' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressPPP_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressIPv4andIPv6_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressIPv4andIPv6_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressIPv4andIPv6_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressIPv4andIPv6_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressIPv4andIPv6_ipv4__address_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressIPv4andIPv6_ipv4__address_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressIPv4andIPv6_ipv4__address_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressIPv4andIPv6_ipv4__address_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressIPv4andIPv6_ipv6__address_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressIPv4andIPv6_ipv6__address_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressIPv4andIPv6_ipv6__address_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressIPv4andIPv6_ipv6__address_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressIPv4andIPv6_encoder(const EndUserAddressIPv4andIPv6& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddressIPv4andIPv6' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressIPv4andIPv6_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressIPv4andIPv6_decoder(OCTETSTRING& input_stream, EndUserAddressIPv4andIPv6& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddressIPv4andIPv6' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressIPv4andIPv6_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressOSPIHOS_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressOSPIHOS_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressOSPIHOS_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressOSPIHOS_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddressOSPIHOS_encoder(const EndUserAddressOSPIHOS& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddressOSPIHOS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddressOSPIHOS_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddressOSPIHOS_decoder(OCTETSTRING& input_stream, EndUserAddressOSPIHOS& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddressOSPIHOS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddressOSPIHOS_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddress__types_encoder(const EndUserAddress__types& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddress_types' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddress__types_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddress__types_decoder(OCTETSTRING& input_stream, EndUserAddress__types& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddress_types' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddress__types_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EndUserAddress_encoder(const EndUserAddress& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddress' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EndUserAddress_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EndUserAddress_decoder(OCTETSTRING& input_stream, EndUserAddress& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EndUserAddress' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EndUserAddress_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSM_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSM_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSM_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSM_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSM_noofVectors_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSM_noofVectors_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSM_noofVectors_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSM_noofVectors_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSM_triplet_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSM_triplet_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSM_msNetW__cap__length_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSM_msNetW__cap__length_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSM_msNetW__cap__length_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSM_msNetW__cap__length_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSM_containerLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSM_containerLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSM_containerLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSM_containerLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSM_access__restriction__data__length_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSM_access__restriction__data__length_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSM_access__restriction__data__length_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSM_access__restriction__data__length_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSM_msNetw__cap_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSM_msNetw__cap_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSM_container_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSM_container_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSM_access__restriction__data_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSM_access__restriction__data_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSM_encoder(const MM__ContextGSM& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_ContextGSM' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSM_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSM_decoder(OCTETSTRING& input_stream, MM__ContextGSM& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_ContextGSM' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSM_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTS_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTS_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_noofVectors_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTS_noofVectors_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_noofVectors_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTS_noofVectors_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_quintupletlength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTS_quintupletlength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_quintupletlength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTS_quintupletlength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_quintuplet_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_quintuplet_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_msNetW__cap__length_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTS_msNetW__cap__length_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_msNetW__cap__length_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTS_msNetW__cap__length_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_containerLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTS_containerLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_containerLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTS_containerLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_access__restriction__data__length_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTS_access__restriction__data__length_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_access__restriction__data__length_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTS_access__restriction__data__length_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_msNetw__cap_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_msNetw__cap_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_container_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_container_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_access__restriction__data_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_access__restriction__data_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTS_encoder(const MM__ContextUMTS& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_ContextUMTS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTS_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTS_decoder(OCTETSTRING& input_stream, MM__ContextUMTS& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_ContextUMTS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTS_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSMUMTS_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSMUMTS_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_noofVectors_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSMUMTS_noofVectors_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_noofVectors_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSMUMTS_noofVectors_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_quintupletlength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSMUMTS_quintupletlength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_quintupletlength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSMUMTS_quintupletlength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_quintuplet_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_quintuplet_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_msNetW__cap__length_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSMUMTS_msNetW__cap__length_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_msNetW__cap__length_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSMUMTS_msNetW__cap__length_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_containerLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSMUMTS_containerLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_containerLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSMUMTS_containerLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_access__restriction__data__length_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSMUMTS_access__restriction__data__length_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_access__restriction__data__length_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSMUMTS_access__restriction__data__length_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_msNetw__cap_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_msNetw__cap_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_container_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_container_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_access__restriction__data_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_access__restriction__data_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextGSMUMTS_encoder(const MM__ContextGSMUMTS& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_ContextGSMUMTS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextGSMUMTS_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextGSMUMTS_decoder(OCTETSTRING& input_stream, MM__ContextGSMUMTS& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_ContextGSMUMTS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextGSMUMTS_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTSReceive_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTSReceive_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_noofVectors_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTSReceive_noofVectors_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_noofVectors_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTSReceive_noofVectors_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_quintupletlength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTSReceive_quintupletlength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_quintupletlength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTSReceive_quintupletlength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_quintuplet_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_quintuplet_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_msNetW__cap__length_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTSReceive_msNetW__cap__length_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_msNetW__cap__length_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTSReceive_msNetW__cap__length_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_containerLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTSReceive_containerLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_containerLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTSReceive_containerLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_access__restriction__data__length_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTSReceive_access__restriction__data__length_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_access__restriction__data__length_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTSReceive_access__restriction__data__length_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_msNetw__cap_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_msNetw__cap_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_container_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_container_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_access__restriction__data_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_access__restriction__data_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextUMTSReceive_encoder(const MM__ContextUMTSReceive& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_ContextUMTSReceive' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextUMTSReceive_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextUMTSReceive_decoder(OCTETSTRING& input_stream, MM__ContextUMTSReceive& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_ContextUMTSReceive' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextUMTSReceive_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__ContextU_encoder(const MM__ContextU& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_ContextU' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__ContextU_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__ContextU_decoder(OCTETSTRING& input_stream, MM__ContextU& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_ContextU' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__ContextU_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MM__Context_encoder(const MM__Context& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_Context' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MM__Context_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MM__Context_decoder(OCTETSTRING& input_stream, MM__Context& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MM_Context' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MM__Context_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTPC__UENetworkCapabilityV_spare4_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTPC__UENetworkCapabilityV_spare4_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTPC__UENetworkCapabilityV_encoder(const GTPC__UENetworkCapabilityV& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_UENetworkCapabilityV' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GTPC__UENetworkCapabilityV_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTPC__UENetworkCapabilityV_decoder(OCTETSTRING& input_stream, GTPC__UENetworkCapabilityV& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_UENetworkCapabilityV' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GTPC__UENetworkCapabilityV_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const PDP__Context__GTPC__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.PDP_Context_GTPC_List."); return other_value.val_ptr->n_elements == 0; } void PDP__Context__GTPC_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_qos__subLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_qos__subLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_qos__subLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_qos__subLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void QoSV__GTPC_encoder(const QoSV__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.QoSV_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(QoSV__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER QoSV__GTPC_decoder(OCTETSTRING& input_stream, QoSV__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.QoSV_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(QoSV__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void QualityOfServiceProfile__Value_encoder(const QualityOfServiceProfile__Value& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.QualityOfServiceProfile_Value' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(QualityOfServiceProfile__Value_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER QualityOfServiceProfile__Value_decoder(OCTETSTRING& input_stream, QualityOfServiceProfile__Value& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.QualityOfServiceProfile_Value' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(QualityOfServiceProfile__Value_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_qos__reqLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_qos__reqLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_qos__reqLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_qos__reqLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_qos__negLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_qos__negLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_qos__negLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_qos__negLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_pdp__addressLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_pdp__addressLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_pdp__addressLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_pdp__addressLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_pdp__address_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_pdp__address_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_ggsn__addressControlPlaneLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_ggsn__addressControlPlaneLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_ggsn__addressControlPlaneLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_ggsn__addressControlPlaneLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_ggsn__addressControlPlane_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_ggsn__addressControlPlane_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_ggsn__addressUserPlaneLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_ggsn__addressUserPlaneLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_ggsn__addressUserPlaneLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_ggsn__addressUserPlaneLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_ggsn__addressUserPlane_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_ggsn__addressUserPlane_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_apnLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_apnLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_apnLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_apnLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_apn_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_apn_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_pdp__typenum2_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_pdp__typenum2_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_pdp__typenum2_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_pdp__typenum2_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_pdp__addresslength2_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_pdp__addresslength2_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_pdp__addresslength2_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_pdp__addresslength2_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_pdp__Address2_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_pdp__Address2_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_pdp__Address2_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_pdp__Address2_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC_encoder(const PDP__Context__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDP_Context_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC_decoder(OCTETSTRING& input_stream, PDP__Context__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDP_Context_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDP__Context__GTPC__List_encoder(const PDP__Context__GTPC__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDP_Context_GTPC_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDP__Context__GTPC__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDP__Context__GTPC__List_decoder(OCTETSTRING& input_stream, PDP__Context__GTPC__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDP_Context_GTPC_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDP__Context__GTPC__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AccessPointName_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AccessPointName_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AccessPointName_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AccessPointName_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AccessPointName_apn__value_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AccessPointName_apn__value_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AccessPointName_encoder(const AccessPointName& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AccessPointName' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AccessPointName_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AccessPointName_decoder(OCTETSTRING& input_stream, AccessPointName& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AccessPointName' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AccessPointName_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ProtConfigOptions_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ProtConfigOptions_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ProtConfigOptions_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ProtConfigOptions_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const ProtocolIDList& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.ProtocolIDList."); return other_value.val_ptr->n_elements == 0; } void ProtocolElement_lengthProtoID_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ProtocolElement_lengthProtoID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ProtocolElement_lengthProtoID_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ProtocolElement_lengthProtoID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ProtocolElement_protoIDContents_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ProtocolElement_protoIDContents_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ProtocolElement_encoder(const ProtocolElement& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ProtocolElement' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ProtocolElement_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ProtocolElement_decoder(OCTETSTRING& input_stream, ProtocolElement& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ProtocolElement' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ProtocolElement_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ProtocolIDList_encoder(const ProtocolIDList& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ProtocolIDList' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ProtocolIDList_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ProtocolIDList_decoder(OCTETSTRING& input_stream, ProtocolIDList& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ProtocolIDList' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ProtocolIDList_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ProtConfigOptions_encoder(const ProtConfigOptions& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ProtConfigOptions' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ProtConfigOptions_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ProtConfigOptions_decoder(OCTETSTRING& input_stream, ProtConfigOptions& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ProtConfigOptions' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ProtConfigOptions_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GSN__Address__GTPC_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GSN__Address__GTPC_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GSN__Address__GTPC_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GSN__Address__GTPC_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GSN__Address__GTPC_addressf_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GSN__Address__GTPC_addressf_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GSN__Address__GTPC_encoder(const GSN__Address__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GSN_Address_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GSN__Address__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GSN__Address__GTPC_decoder(OCTETSTRING& input_stream, GSN__Address__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GSN_Address_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GSN__Address__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MSISDN_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MSISDN_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MSISDN_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MSISDN_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MSISDN_msisdn_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MSISDN_msisdn_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MSISDN_encoder(const MSISDN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MSISDN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MSISDN_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MSISDN_decoder(OCTETSTRING& input_stream, MSISDN& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MSISDN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MSISDN_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void QualityOfServiceProfile_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(QualityOfServiceProfile_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER QualityOfServiceProfile_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(QualityOfServiceProfile_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void QualityOfServiceProfile_encoder(const QualityOfServiceProfile& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.QualityOfServiceProfile' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(QualityOfServiceProfile_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER QualityOfServiceProfile_decoder(OCTETSTRING& input_stream, QualityOfServiceProfile& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.QualityOfServiceProfile' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(QualityOfServiceProfile_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AuthenticationQuintuplet__GTPC_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AuthenticationQuintuplet__GTPC_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AuthenticationQuintuplet__GTPC_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AuthenticationQuintuplet__GTPC_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AuthenticationQuintuplet__GTPC_xresLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AuthenticationQuintuplet__GTPC_xresLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AuthenticationQuintuplet__GTPC_xresLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AuthenticationQuintuplet__GTPC_xresLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AuthenticationQuintuplet__GTPC_xres_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AuthenticationQuintuplet__GTPC_xres_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AuthenticationQuintuplet__GTPC_autnLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AuthenticationQuintuplet__GTPC_autnLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AuthenticationQuintuplet__GTPC_autnLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AuthenticationQuintuplet__GTPC_autnLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AuthenticationQuintuplet__GTPC_autn_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AuthenticationQuintuplet__GTPC_autn_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AuthenticationQuintuplet__GTPC_encoder(const AuthenticationQuintuplet__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AuthenticationQuintuplet_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AuthenticationQuintuplet__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AuthenticationQuintuplet__GTPC_decoder(OCTETSTRING& input_stream, AuthenticationQuintuplet__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AuthenticationQuintuplet_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AuthenticationQuintuplet__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplate_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplate_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplate_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplate_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_numberOfPacketFilters_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_numberOfPacketFilters_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_numberOfPacketFilters_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_numberOfPacketFilters_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const PacketFilterList__CreateAddReplaceTFT__GTPC& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.PacketFilterList_CreateAddReplaceTFT_GTPC."); return other_value.val_ptr->n_elements == 0; } void PacketFilter__GTPC_lengthIndicator_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PacketFilter__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PacketFilter__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PacketFilter__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PacketFilter__GTPC_contents_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PacketFilter__GTPC_contents_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PacketFilter__GTPC_encoder(const PacketFilter__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PacketFilter_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PacketFilter__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PacketFilter__GTPC_decoder(OCTETSTRING& input_stream, PacketFilter__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PacketFilter_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PacketFilter__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PacketFilterList__CreateAddReplaceTFT__GTPC_encoder(const PacketFilterList__CreateAddReplaceTFT__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PacketFilterList_CreateAddReplaceTFT_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PacketFilterList__CreateAddReplaceTFT__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PacketFilterList__CreateAddReplaceTFT__GTPC_decoder(OCTETSTRING& input_stream, PacketFilterList__CreateAddReplaceTFT__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PacketFilterList_CreateAddReplaceTFT_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PacketFilterList__CreateAddReplaceTFT__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const ParametersList__GTPC& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.ParametersList_GTPC."); return other_value.val_ptr->n_elements == 0; } void Parameter__GTPC_lengthIndicator_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Parameter__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Parameter__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Parameter__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Parameter__GTPC_contents_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Parameter__GTPC_contents_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Parameter__GTPC_encoder(const Parameter__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Parameter_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Parameter__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Parameter__GTPC_decoder(OCTETSTRING& input_stream, Parameter__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Parameter_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Parameter__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ParametersList__GTPC_encoder(const ParametersList__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ParametersList_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ParametersList__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ParametersList__GTPC_decoder(OCTETSTRING& input_stream, ParametersList__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ParametersList_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ParametersList__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_parametersList_encoder(const ParametersList__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ParametersList_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_parametersList_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_parametersList_decoder(OCTETSTRING& input_stream, ParametersList__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ParametersList_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_parametersList_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_encoder(const TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TrafficFlowTemplateV_CreateAddReplaceTFT_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_decoder(OCTETSTRING& input_stream, TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TrafficFlowTemplateV_CreateAddReplaceTFT_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplateV__CreateAddReplaceTFT__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplateV__DeletePacketFilter__GTPC_numberOfPacketFilters_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplateV__DeletePacketFilter__GTPC_numberOfPacketFilters_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplateV__DeletePacketFilter__GTPC_numberOfPacketFilters_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplateV__DeletePacketFilter__GTPC_numberOfPacketFilters_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PacketFilterList__DeletePacketFilter__GTPC_encoder(const PacketFilterList__DeletePacketFilter__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PacketFilterList_DeletePacketFilter_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PacketFilterList__DeletePacketFilter__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PacketFilterList__DeletePacketFilter__GTPC_decoder(OCTETSTRING& input_stream, PacketFilterList__DeletePacketFilter__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PacketFilterList_DeletePacketFilter_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PacketFilterList__DeletePacketFilter__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplateV__DeletePacketFilter__GTPC_parametersList_encoder(const ParametersList__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ParametersList_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplateV__DeletePacketFilter__GTPC_parametersList_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplateV__DeletePacketFilter__GTPC_parametersList_decoder(OCTETSTRING& input_stream, ParametersList__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ParametersList_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplateV__DeletePacketFilter__GTPC_parametersList_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplateV__DeletePacketFilter__GTPC_encoder(const TrafficFlowTemplateV__DeletePacketFilter__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TrafficFlowTemplateV_DeletePacketFilter_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplateV__DeletePacketFilter__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplateV__DeletePacketFilter__GTPC_decoder(OCTETSTRING& input_stream, TrafficFlowTemplateV__DeletePacketFilter__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TrafficFlowTemplateV_DeletePacketFilter_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplateV__DeletePacketFilter__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplateV__Delete__Existing__TFT__or__No__TFT__Operation__GTPC_parametersList_encoder(const ParametersList__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ParametersList_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplateV__Delete__Existing__TFT__or__No__TFT__Operation__GTPC_parametersList_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplateV__Delete__Existing__TFT__or__No__TFT__Operation__GTPC_parametersList_decoder(OCTETSTRING& input_stream, ParametersList__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ParametersList_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplateV__Delete__Existing__TFT__or__No__TFT__Operation__GTPC_parametersList_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplateV__Delete__Existing__TFT__or__No__TFT__Operation__GTPC_encoder(const TrafficFlowTemplateV__Delete__Existing__TFT__or__No__TFT__Operation__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TrafficFlowTemplateV_Delete_Existing_TFT_or_No_TFT_Operation_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplateV__Delete__Existing__TFT__or__No__TFT__Operation__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplateV__Delete__Existing__TFT__or__No__TFT__Operation__GTPC_decoder(OCTETSTRING& input_stream, TrafficFlowTemplateV__Delete__Existing__TFT__or__No__TFT__Operation__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TrafficFlowTemplateV_Delete_Existing_TFT_or_No_TFT_Operation_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplateV__Delete__Existing__TFT__or__No__TFT__Operation__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplateV__GTPC_encoder(const TrafficFlowTemplateV__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TrafficFlowTemplateV_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplateV__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplateV__GTPC_decoder(OCTETSTRING& input_stream, TrafficFlowTemplateV__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TrafficFlowTemplateV_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplateV__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TrafficFlowTemplate_encoder(const TrafficFlowTemplate& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TrafficFlowTemplate' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TrafficFlowTemplate_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TrafficFlowTemplate_decoder(OCTETSTRING& input_stream, TrafficFlowTemplate& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TrafficFlowTemplate' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TrafficFlowTemplate_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TargetIdentification_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TargetIdentification_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TargetIdentification_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TargetIdentification_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TargetIdentification_extended__rnc__id_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TargetIdentification_extended__rnc__id_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TargetIdentification_encoder(const TargetIdentification& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TargetIdentification' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TargetIdentification_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TargetIdentification_decoder(OCTETSTRING& input_stream, TargetIdentification& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TargetIdentification' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TargetIdentification_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UTRANTransparentContainer_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UTRANTransparentContainer_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UTRANTransparentContainer_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UTRANTransparentContainer_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UTRANTransparentContainer_transparentfield_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UTRANTransparentContainer_transparentfield_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UTRANTransparentContainer_encoder(const UTRANTransparentContainer& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UTRANTransparentContainer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UTRANTransparentContainer_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UTRANTransparentContainer_decoder(OCTETSTRING& input_stream, UTRANTransparentContainer& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UTRANTransparentContainer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UTRANTransparentContainer_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const RABSetupInformation__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.RABSetupInformation_List."); return other_value.val_ptr->n_elements == 0; } void RABSetupInformation_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RABSetupInformation_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RABSetupInformation_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RABSetupInformation_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RABSetupInformation_rncIpAddress_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RABSetupInformation_rncIpAddress_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RABSetupInformation_encoder(const RABSetupInformation& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RABSetupInformation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RABSetupInformation_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RABSetupInformation_decoder(OCTETSTRING& input_stream, RABSetupInformation& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RABSetupInformation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RABSetupInformation_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RABSetupInformation__List_encoder(const RABSetupInformation__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RABSetupInformation_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RABSetupInformation__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RABSetupInformation__List_decoder(OCTETSTRING& input_stream, RABSetupInformation__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RABSetupInformation_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RABSetupInformation__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ExtensionHeaderTypeList__gtpc_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ExtensionHeaderTypeList__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ExtensionHeaderTypeList__gtpc_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ExtensionHeaderTypeList__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ExtensionHeaderTypeList__gtpc_extensionTypesList_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ExtensionHeaderTypeList__gtpc_extensionTypesList_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ExtensionHeaderTypeList__gtpc_encoder(const ExtensionHeaderTypeList__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ExtensionHeaderTypeList_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ExtensionHeaderTypeList__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ExtensionHeaderTypeList__gtpc_decoder(OCTETSTRING& input_stream, ExtensionHeaderTypeList__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ExtensionHeaderTypeList_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ExtensionHeaderTypeList__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTP__TriggerID_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GTP__TriggerID_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTP__TriggerID_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GTP__TriggerID_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTP__TriggerID_triggerID_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTP__TriggerID_triggerID_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTP__TriggerID_encoder(const GTP__TriggerID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTP_TriggerID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GTP__TriggerID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTP__TriggerID_decoder(OCTETSTRING& input_stream, GTP__TriggerID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTP_TriggerID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GTP__TriggerID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void OMCIdentity_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OMCIdentity_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER OMCIdentity_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OMCIdentity_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void OMCIdentity_omcID_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER OMCIdentity_omcID_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void OMCIdentity_encoder(const OMCIdentity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.OMCIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OMCIdentity_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER OMCIdentity_decoder(OCTETSTRING& input_stream, OMCIdentity& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.OMCIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OMCIdentity_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void LIN2__2a__GTPC_length1_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(LIN2__2a__GTPC_length1_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER LIN2__2a__GTPC_length1_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(LIN2__2a__GTPC_length1_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void LIN2__2a__GTPC_length2_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(LIN2__2a__GTPC_length2_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER LIN2__2a__GTPC_length2_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(LIN2__2a__GTPC_length2_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void LIN2__2a__GTPC_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(LIN2__2a__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER LIN2__2a__GTPC_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(LIN2__2a__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__in__Error__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__in__Error__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__in__Error__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__in__Error__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__in__Error__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__in__Error__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__in__Error__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__in__Error__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__in__Error__GTPC_erroneous__BSSGP__PDU_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__in__Error__GTPC_erroneous__BSSGP__PDU_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__in__Error__GTPC_encoder(const PDU__in__Error__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_in_Error_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__in__Error__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__in__Error__GTPC_decoder(OCTETSTRING& input_stream, PDU__in__Error__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_in_Error_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__in__Error__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Cause__BSSGP__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Cause__BSSGP__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Cause__BSSGP__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Cause__BSSGP__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Cause__BSSGP__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Cause__BSSGP__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Cause__BSSGP__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Cause__BSSGP__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Cause__BSSGP__GTPC_encoder(const Cause__BSSGP__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Cause_BSSGP_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Cause__BSSGP__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Cause__BSSGP__GTPC_decoder(OCTETSTRING& input_stream, Cause__BSSGP__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Cause_BSSGP_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Cause__BSSGP__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Application__Identity__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Application__Identity__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Application__Identity__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Application__Identity__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Application__Identity__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Application__Identity__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Application__Identity__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Application__Identity__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Application__Identity__GTPC_encoder(const RIM__Application__Identity__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Application_Identity_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Application__Identity__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Application__Identity__GTPC_decoder(OCTETSTRING& input_stream, RIM__Application__Identity__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Application_Identity_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Application__Identity__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Sequence__Number__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Sequence__Number__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Sequence__Number__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Sequence__Number__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Sequence__Number__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Sequence__Number__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Sequence__Number__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Sequence__Number__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Sequence__Number__GTPC_encoder(const RIM__Sequence__Number__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Sequence_Number_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Sequence__Number__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Sequence__Number__GTPC_decoder(OCTETSTRING& input_stream, RIM__Sequence__Number__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Sequence_Number_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Sequence__Number__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__RIM__Container__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__RIM__Container__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__RIM__Container__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__RIM__Container__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__RIM__Container__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__RIM__Container__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__RIM__Container__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__RIM__Container__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__PDU__Indications__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__PDU__Indications__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__PDU__Indications__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__PDU__Indications__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__PDU__Indications__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__PDU__Indications__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__PDU__Indications__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__PDU__Indications__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__PDU__Indications__GTPC_encoder(const RIM__PDU__Indications__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_PDU_Indications_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__PDU__Indications__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__PDU__Indications__GTPC_decoder(OCTETSTRING& input_stream, RIM__PDU__Indications__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_PDU_Indications_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__PDU__Indications__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Protocol__Version__Number__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Protocol__Version__Number__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Protocol__Version__Number__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Protocol__Version__Number__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Protocol__Version__Number__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Protocol__Version__Number__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Protocol__Version__Number__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Protocol__Version__Number__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Protocol__Version__Number__GTPC_encoder(const RIM__Protocol__Version__Number__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Protocol_Version_Number_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Protocol__Version__Number__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Protocol__Version__Number__GTPC_decoder(OCTETSTRING& input_stream, RIM__Protocol__Version__Number__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Protocol_Version_Number_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Protocol__Version__Number__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__NACC__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__NACC__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__NACC__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__NACC__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__NACC__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__NACC__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__NACC__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__NACC__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Cell__Identifier__V__GTPC_encoder(const Cell__Identifier__V__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Cell_Identifier_V_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Cell__Identifier__V__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Cell__Identifier__V__GTPC_decoder(OCTETSTRING& input_stream, Cell__Identifier__V__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Cell_Identifier_V_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Cell__Identifier__V__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__NACC__GTPC_encoder(const RAN__Information__Request__Application__Container__NACC__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_NACC_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__NACC__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__NACC__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Request__Application__Container__NACC__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_NACC_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__NACC__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__SI3__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__SI3__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__SI3__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__SI3__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__SI3__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__SI3__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__SI3__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__SI3__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__SI3__GTPC_encoder(const RAN__Information__Request__Application__Container__SI3__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_SI3_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__SI3__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__SI3__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Request__Application__Container__SI3__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_SI3_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__SI3__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__MBMS__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__MBMS__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__MBMS__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__MBMS__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__MBMS__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__MBMS__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__MBMS__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__MBMS__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__MBMS__GTPC_encoder(const RAN__Information__Request__Application__Container__MBMS__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_MBMS_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__MBMS__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__MBMS__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Request__Application__Container__MBMS__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_MBMS_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__MBMS__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__SON__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__SON__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__SON__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__SON__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__SON__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__SON__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__SON__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__SON__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__SON__GTPC_sON__TransferRequestContainer_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__SON__GTPC_sON__TransferRequestContainer_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__SON__GTPC_encoder(const RAN__Information__Request__Application__Container__SON__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_SON_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__SON__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__SON__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Request__Application__Container__SON__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_SON_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__SON__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__UTRA__SI__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__UTRA__SI__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__UTRA__SI__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__UTRA__SI__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__UTRA__SI__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__UTRA__SI__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__UTRA__SI__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__UTRA__SI__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__UTRA__SI__GTPC_encoder(const RAN__Information__Request__Application__Container__UTRA__SI__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_UTRA_SI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__UTRA__SI__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__UTRA__SI__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Request__Application__Container__UTRA__SI__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_UTRA_SI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__UTRA__SI__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__Application__Container__GTPC_encoder(const RAN__Information__Request__Application__Container__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__Application__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__Application__Container__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Request__Application__Container__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__Application__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__RIM__Container__GTPC_application__Container_encoder(const RAN__Information__Request__Application__Container__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__RIM__Container__GTPC_application__Container_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__RIM__Container__GTPC_application__Container_decoder(OCTETSTRING& input_stream, RAN__Information__Request__Application__Container__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_Application_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__RIM__Container__GTPC_application__Container_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SON__TransferApplicationIdentity_sON__TransferApplicationIdentityValue_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SON__TransferApplicationIdentity_sON__TransferApplicationIdentityValue_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SON__TransferApplicationIdentity_encoder(const SON__TransferApplicationIdentity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SON__TransferApplicationIdentity_decoder(OCTETSTRING& input_stream, SON__TransferApplicationIdentity& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__RIM__Container__GTPC_sON__TransferApplicationIdentity_encoder(const SON__TransferApplicationIdentity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__RIM__Container__GTPC_sON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__RIM__Container__GTPC_sON__TransferApplicationIdentity_decoder(OCTETSTRING& input_stream, SON__TransferApplicationIdentity& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__RIM__Container__GTPC_sON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Request__RIM__Container__GTPC_encoder(const RAN__Information__Request__RIM__Container__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_RIM_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Request__RIM__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Request__RIM__Container__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Request__RIM__Container__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Request_RIM_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Request__RIM__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__RIM__Container__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__RIM__Container__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__RIM__Container__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__RIM__Container__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__RIM__Container__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__RIM__Container__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__RIM__Container__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__RIM__Container__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__NACC__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__NACC__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__NACC__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__NACC__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__NACC__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__NACC__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__NACC__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__NACC__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__NACC__GTPC_sI__PSI_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__NACC__GTPC_sI__PSI_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__NACC__GTPC_encoder(const RAN__Information__Application__Container__NACC__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Container_NACC_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__NACC__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__NACC__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Application__Container__NACC__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Container_NACC_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__NACC__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__NACC__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__NACC__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__NACC__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__NACC__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__NACC__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__NACC__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__NACC__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__NACC__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Container__IE__NACC__GTPC_encoder(const Application__Container__IE__NACC__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Container_IE_NACC_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Container__IE__NACC__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Container__IE__NACC__GTPC_decoder(OCTETSTRING& input_stream, Application__Container__IE__NACC__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Container_IE_NACC_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Container__IE__NACC__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__NACC__GTPC_encoder(const Application__Error__Container__NACC__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_NACC_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__NACC__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__NACC__GTPC_decoder(OCTETSTRING& input_stream, Application__Error__Container__NACC__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_NACC_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__NACC__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ApplContainer__or__ApplErrContainer__NACC__GTPC_encoder(const ApplContainer__or__ApplErrContainer__NACC__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_NACC_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ApplContainer__or__ApplErrContainer__NACC__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ApplContainer__or__ApplErrContainer__NACC__GTPC_decoder(OCTETSTRING& input_stream, ApplContainer__or__ApplErrContainer__NACC__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_NACC_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ApplContainer__or__ApplErrContainer__NACC__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__SI3__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__SI3__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__SI3__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__SI3__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__SI3__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__SI3__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__SI3__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__SI3__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__SI3__GTPC_sI3_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__SI3__GTPC_sI3_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__SI3__GTPC_sI3_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__SI3__GTPC_sI3_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__SI3__GTPC_encoder(const RAN__Information__Application__Container__SI3__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Container_SI3_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__SI3__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__SI3__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Application__Container__SI3__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Container_SI3_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__SI3__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__SI3__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__SI3__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__SI3__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__SI3__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__SI3__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__SI3__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__SI3__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__SI3__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Container__IE__SI3__GTPC_encoder(const Application__Container__IE__SI3__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Container_IE_SI3_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Container__IE__SI3__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Container__IE__SI3__GTPC_decoder(OCTETSTRING& input_stream, Application__Container__IE__SI3__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Container_IE_SI3_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Container__IE__SI3__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__SI3__GTPC_encoder(const Application__Error__Container__SI3__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_SI3_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__SI3__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__SI3__GTPC_decoder(OCTETSTRING& input_stream, Application__Error__Container__SI3__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_SI3_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__SI3__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ApplContainer__or__ApplErrContainer__SI3__GTPC_encoder(const ApplContainer__or__ApplErrContainer__SI3__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_SI3_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ApplContainer__or__ApplErrContainer__SI3__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ApplContainer__or__ApplErrContainer__SI3__GTPC_decoder(OCTETSTRING& input_stream, ApplContainer__or__ApplErrContainer__SI3__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_SI3_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ApplContainer__or__ApplErrContainer__SI3__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__MBMS__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__MBMS__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__MBMS__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__MBMS__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__MBMS__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__MBMS__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__MBMS__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__MBMS__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__MBMS__GTPC_mBMS__ChannelReport_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__MBMS__GTPC_mBMS__ChannelReport_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__MBMS__GTPC_encoder(const RAN__Information__Application__Container__MBMS__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Container_MBMS_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__MBMS__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__MBMS__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Application__Container__MBMS__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Container_MBMS_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__MBMS__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__MBMS__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__MBMS__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__MBMS__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__MBMS__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__MBMS__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__MBMS__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__MBMS__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__MBMS__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Container__IE__MBMS__GTPC_encoder(const Application__Container__IE__MBMS__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Container_IE_MBMS_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Container__IE__MBMS__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Container__IE__MBMS__GTPC_decoder(OCTETSTRING& input_stream, Application__Container__IE__MBMS__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Container_IE_MBMS_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Container__IE__MBMS__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__MBMS__GTPC_encoder(const Application__Error__Container__MBMS__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_MBMS_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__MBMS__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__MBMS__GTPC_decoder(OCTETSTRING& input_stream, Application__Error__Container__MBMS__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_MBMS_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__MBMS__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ApplContainer__or__ApplErrContainer__MBMS__GTPC_encoder(const ApplContainer__or__ApplErrContainer__MBMS__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_MBMS_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ApplContainer__or__ApplErrContainer__MBMS__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ApplContainer__or__ApplErrContainer__MBMS__GTPC_decoder(OCTETSTRING& input_stream, ApplContainer__or__ApplErrContainer__MBMS__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_MBMS_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ApplContainer__or__ApplErrContainer__MBMS__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__SON__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__SON__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__SON__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__SON__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__SON__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__SON__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__SON__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__SON__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__SON__GTPC_sON__TransferResponseContainer_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__SON__GTPC_sON__TransferResponseContainer_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__SON__GTPC_encoder(const RAN__Information__Application__Container__SON__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Container_SON_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__SON__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__SON__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Application__Container__SON__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Container_SON_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__SON__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__SON__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__SON__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__SON__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__SON__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__SON__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__SON__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__SON__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__SON__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Container__IE__SON__GTPC_encoder(const Application__Container__IE__SON__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Container_IE_SON_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Container__IE__SON__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Container__IE__SON__GTPC_decoder(OCTETSTRING& input_stream, Application__Container__IE__SON__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Container_IE_SON_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Container__IE__SON__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__SON__GTPC_encoder(const Application__Error__Container__SON__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_SON_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__SON__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__SON__GTPC_decoder(OCTETSTRING& input_stream, Application__Error__Container__SON__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_SON_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__SON__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ApplContainer__or__ApplErrContainer__SON__GTPC_encoder(const ApplContainer__or__ApplErrContainer__SON__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_SON_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ApplContainer__or__ApplErrContainer__SON__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ApplContainer__or__ApplErrContainer__SON__GTPC_decoder(OCTETSTRING& input_stream, ApplContainer__or__ApplErrContainer__SON__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_SON_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ApplContainer__or__ApplErrContainer__SON__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__UTRA__SI__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__UTRA__SI__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__UTRA__SI__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__UTRA__SI__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__UTRA__SI__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__UTRA__SI__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__UTRA__SI__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__UTRA__SI__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__UTRA__SI__GTPC_uTRA__SI__Container_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__UTRA__SI__GTPC_uTRA__SI__Container_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Container__UTRA__SI__GTPC_encoder(const RAN__Information__Application__Container__UTRA__SI__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Container_UTRA_SI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Container__UTRA__SI__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Container__UTRA__SI__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Application__Container__UTRA__SI__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Container_UTRA_SI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Container__UTRA__SI__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__UTRA__SI__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__UTRA__SI__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__UTRA__SI__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__UTRA__SI__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__UTRA__SI__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__UTRA__SI__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__UTRA__SI__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__UTRA__SI__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__UTRA__SI__GTPC_encoder(const Application__Error__Container__UTRA__SI__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_UTRA_SI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__UTRA__SI__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__UTRA__SI__GTPC_decoder(OCTETSTRING& input_stream, Application__Error__Container__UTRA__SI__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_UTRA_SI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__UTRA__SI__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ApplContainer__or__ApplErrContainer__UTRA__SI__GTPC_encoder(const ApplContainer__or__ApplErrContainer__UTRA__SI__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_UTRA_SI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ApplContainer__or__ApplErrContainer__UTRA__SI__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ApplContainer__or__ApplErrContainer__UTRA__SI__GTPC_decoder(OCTETSTRING& input_stream, ApplContainer__or__ApplErrContainer__UTRA__SI__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_UTRA_SI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ApplContainer__or__ApplErrContainer__UTRA__SI__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ApplContainer__or__ApplErrContainer__GTPC_encoder(const ApplContainer__or__ApplErrContainer__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ApplContainer__or__ApplErrContainer__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ApplContainer__or__ApplErrContainer__GTPC_decoder(OCTETSTRING& input_stream, ApplContainer__or__ApplErrContainer__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ApplContainer__or__ApplErrContainer__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__RIM__Container__GTPC_applContainer__or__ApplErrContainer_encoder(const ApplContainer__or__ApplErrContainer__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__RIM__Container__GTPC_applContainer__or__ApplErrContainer_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__RIM__Container__GTPC_applContainer__or__ApplErrContainer_decoder(OCTETSTRING& input_stream, ApplContainer__or__ApplErrContainer__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ApplContainer_or_ApplErrContainer_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__RIM__Container__GTPC_applContainer__or__ApplErrContainer_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__RIM__Container__GTPC_sON__TransferApplicationIdentity_encoder(const SON__TransferApplicationIdentity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__RIM__Container__GTPC_sON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__RIM__Container__GTPC_sON__TransferApplicationIdentity_decoder(OCTETSTRING& input_stream, SON__TransferApplicationIdentity& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__RIM__Container__GTPC_sON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__RIM__Container__GTPC_encoder(const RAN__Information__RIM__Container__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_RIM_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__RIM__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__RIM__Container__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__RIM__Container__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_RIM_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__RIM__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Ack__RIM__Container__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Ack__RIM__Container__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Ack__RIM__Container__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Ack__RIM__Container__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Ack__RIM__Container__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Ack__RIM__Container__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Ack__RIM__Container__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Ack__RIM__Container__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Ack__RIM__Container__GTPC_sON__TransferApplicationIdentity_encoder(const SON__TransferApplicationIdentity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Ack__RIM__Container__GTPC_sON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Ack__RIM__Container__GTPC_sON__TransferApplicationIdentity_decoder(OCTETSTRING& input_stream, SON__TransferApplicationIdentity& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Ack__RIM__Container__GTPC_sON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Ack__RIM__Container__GTPC_encoder(const RAN__Information__Ack__RIM__Container__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Ack_RIM_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Ack__RIM__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Ack__RIM__Container__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Ack__RIM__Container__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Ack_RIM_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Ack__RIM__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Error__RIM__Container__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Error__RIM__Container__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Error__RIM__Container__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Error__RIM__Container__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Error__RIM__Container__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Error__RIM__Container__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Error__RIM__Container__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Error__RIM__Container__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Error__RIM__Container__GTPC_sON__TransferApplicationIdentity_encoder(const SON__TransferApplicationIdentity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Error__RIM__Container__GTPC_sON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Error__RIM__Container__GTPC_sON__TransferApplicationIdentity_decoder(OCTETSTRING& input_stream, SON__TransferApplicationIdentity& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Error__RIM__Container__GTPC_sON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Error__RIM__Container__GTPC_encoder(const RAN__Information__Error__RIM__Container__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Error_RIM_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Error__RIM__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Error__RIM__Container__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Error__RIM__Container__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Error_RIM_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Error__RIM__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Error__RIM__Container__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Error__RIM__Container__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Error__RIM__Container__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Error__RIM__Container__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Error__RIM__Container__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Error__RIM__Container__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Error__RIM__Container__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Error__RIM__Container__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Error__Container__GTPC_encoder(const Application__Error__Container__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Error__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Error__Container__GTPC_decoder(OCTETSTRING& input_stream, Application__Error__Container__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Error__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Error__RIM__Container__GTPC_application__Error__Container_encoder(const Application__Error__Container__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Error__RIM__Container__GTPC_application__Error__Container_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Error__RIM__Container__GTPC_application__Error__Container_decoder(OCTETSTRING& input_stream, Application__Error__Container__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Error_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Error__RIM__Container__GTPC_application__Error__Container_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Error__RIM__Container__GTPC_sON__TransferApplicationIdentity_encoder(const SON__TransferApplicationIdentity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Error__RIM__Container__GTPC_sON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Error__RIM__Container__GTPC_sON__TransferApplicationIdentity_decoder(OCTETSTRING& input_stream, SON__TransferApplicationIdentity& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SON_TransferApplicationIdentity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Error__RIM__Container__GTPC_sON__TransferApplicationIdentity_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RAN__Information__Application__Error__RIM__Container__GTPC_encoder(const RAN__Information__Application__Error__RIM__Container__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Error_RIM_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RAN__Information__Application__Error__RIM__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RAN__Information__Application__Error__RIM__Container__GTPC_decoder(OCTETSTRING& input_stream, RAN__Information__Application__Error__RIM__Container__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RAN_Information_Application_Error_RIM_Container_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RAN__Information__Application__Error__RIM__Container__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Application__Container__IE__UTRA__SI__GTPC_encoder(const Application__Container__IE__UTRA__SI__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Container_IE_UTRA_SI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Application__Container__IE__UTRA__SI__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Application__Container__IE__UTRA__SI__GTPC_decoder(OCTETSTRING& input_stream, Application__Container__IE__UTRA__SI__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Application_Container_IE_UTRA_SI_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Application__Container__IE__UTRA__SI__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Routing__Information__GTPC_ext_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Routing__Information__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Routing__Information__GTPC_ext_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Routing__Information__GTPC_ext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Routing__Information__GTPC_lengthIndicator_encoder(const LIN2__2a__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Routing__Information__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Routing__Information__GTPC_lengthIndicator_decoder(OCTETSTRING& input_stream, LIN2__2a__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LIN2_2a_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Routing__Information__GTPC_lengthIndicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RNC__ID__BSSGP__GTPC_spare_encoder(const HEXSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `hexstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RNC__ID__BSSGP__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RNC__ID__BSSGP__GTPC_spare_decoder(OCTETSTRING& input_stream, HEXSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `hexstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RNC__ID__BSSGP__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RNC__ID__BSSGP__GTPC_rNC__ID_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RNC__ID__BSSGP__GTPC_rNC__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RNC__ID__BSSGP__GTPC_rNC__ID_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RNC__ID__BSSGP__GTPC_rNC__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RNC__ID__BSSGP__GTPC_encoder(const RNC__ID__BSSGP__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RNC_ID_BSSGP_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RNC__ID__BSSGP__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RNC__ID__BSSGP__GTPC_decoder(OCTETSTRING& input_stream, RNC__ID__BSSGP__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RNC_ID_BSSGP_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RNC__ID__BSSGP__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ENB__Identifier_globalENB__ID_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ENB__Identifier_globalENB__ID_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ENB__Identifier_encoder(const ENB__Identifier& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ENB_Identifier' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ENB__Identifier_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ENB__Identifier_decoder(OCTETSTRING& input_stream, ENB__Identifier& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ENB_Identifier' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ENB__Identifier_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Routing__Address__GTPC_encoder(const RIM__Routing__Address__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Routing_Address_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Routing__Address__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Routing__Address__GTPC_decoder(OCTETSTRING& input_stream, RIM__Routing__Address__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Routing_Address_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Routing__Address__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Routing__Information__GTPC_rIM__Routing__Address_encoder(const RIM__Routing__Address__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Routing_Address_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Routing__Information__GTPC_rIM__Routing__Address_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Routing__Information__GTPC_rIM__Routing__Address_decoder(OCTETSTRING& input_stream, RIM__Routing__Address__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Routing_Address_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Routing__Information__GTPC_rIM__Routing__Address_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__Routing__Information__GTPC_encoder(const RIM__Routing__Information__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Routing_Information_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__Routing__Information__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__Routing__Information__GTPC_decoder(OCTETSTRING& input_stream, RIM__Routing__Information__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_Routing_Information_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__Routing__Information__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__BSSGP__RAN__INFORMATION__REQUEST__GTPC_encoder(const PDU__BSSGP__RAN__INFORMATION__REQUEST__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_BSSGP_RAN_INFORMATION_REQUEST_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__BSSGP__RAN__INFORMATION__REQUEST__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__BSSGP__RAN__INFORMATION__REQUEST__GTPC_decoder(OCTETSTRING& input_stream, PDU__BSSGP__RAN__INFORMATION__REQUEST__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_BSSGP_RAN_INFORMATION_REQUEST_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__BSSGP__RAN__INFORMATION__REQUEST__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__BSSGP__RAN__INFORMATION__GTPC_encoder(const PDU__BSSGP__RAN__INFORMATION__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_BSSGP_RAN_INFORMATION_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__BSSGP__RAN__INFORMATION__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__BSSGP__RAN__INFORMATION__GTPC_decoder(OCTETSTRING& input_stream, PDU__BSSGP__RAN__INFORMATION__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_BSSGP_RAN_INFORMATION_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__BSSGP__RAN__INFORMATION__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__BSSGP__RAN__INFORMATION__ACK__GTPC_encoder(const PDU__BSSGP__RAN__INFORMATION__ACK__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_BSSGP_RAN_INFORMATION_ACK_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__BSSGP__RAN__INFORMATION__ACK__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__BSSGP__RAN__INFORMATION__ACK__GTPC_decoder(OCTETSTRING& input_stream, PDU__BSSGP__RAN__INFORMATION__ACK__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_BSSGP_RAN_INFORMATION_ACK_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__BSSGP__RAN__INFORMATION__ACK__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__BSSGP__RAN__INFORMATION__ERROR__GTPC_encoder(const PDU__BSSGP__RAN__INFORMATION__ERROR__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_BSSGP_RAN_INFORMATION_ERROR_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__BSSGP__RAN__INFORMATION__ERROR__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__BSSGP__RAN__INFORMATION__ERROR__GTPC_decoder(OCTETSTRING& input_stream, PDU__BSSGP__RAN__INFORMATION__ERROR__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_BSSGP_RAN_INFORMATION_ERROR_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__BSSGP__RAN__INFORMATION__ERROR__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__BSSGP__RAN__INFORMATION__APPLICATION__ERROR__GTPC_encoder(const PDU__BSSGP__RAN__INFORMATION__APPLICATION__ERROR__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_BSSGP_RAN_INFORMATION_APPLICATION_ERROR_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__BSSGP__RAN__INFORMATION__APPLICATION__ERROR__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__BSSGP__RAN__INFORMATION__APPLICATION__ERROR__GTPC_decoder(OCTETSTRING& input_stream, PDU__BSSGP__RAN__INFORMATION__APPLICATION__ERROR__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_BSSGP_RAN_INFORMATION_APPLICATION_ERROR_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__BSSGP__RAN__INFORMATION__APPLICATION__ERROR__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RANTransparentContainerField_encoder(const RANTransparentContainerField& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RANTransparentContainerField' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RANTransparentContainerField_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RANTransparentContainerField_decoder(OCTETSTRING& input_stream, RANTransparentContainerField& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RANTransparentContainerField' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RANTransparentContainerField_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RANTransparentContainer_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RANTransparentContainer_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RANTransparentContainer_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RANTransparentContainer_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RANTransparentContainer_encoder(const RANTransparentContainer& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RANTransparentContainer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RANTransparentContainer_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RANTransparentContainer_decoder(OCTETSTRING& input_stream, RANTransparentContainer& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RANTransparentContainer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RANTransparentContainer_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ChargingGatewayAddress_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ChargingGatewayAddress_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ChargingGatewayAddress_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ChargingGatewayAddress_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void iPv4__iPv6__Address_encoder(const iPv4__iPv6__Address& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.iPv4_iPv6_Address' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(iPv4__iPv6__Address_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER iPv4__iPv6__Address_decoder(OCTETSTRING& input_stream, iPv4__iPv6__Address& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.iPv4_iPv6_Address' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(iPv4__iPv6__Address_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ChargingGatewayAddress_encoder(const ChargingGatewayAddress& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ChargingGatewayAddress' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ChargingGatewayAddress_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ChargingGatewayAddress_decoder(OCTETSTRING& input_stream, ChargingGatewayAddress& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ChargingGatewayAddress' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ChargingGatewayAddress_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDPContextPriorization_encoder(const PDPContextPriorization& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDPContextPriorization' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDPContextPriorization_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDPContextPriorization_decoder(OCTETSTRING& input_stream, PDPContextPriorization& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDPContextPriorization' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDPContextPriorization_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const AdditionalRABSetupInformation__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.AdditionalRABSetupInformation_List."); return other_value.val_ptr->n_elements == 0; } void AdditionalRABSetupInformation_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AdditionalRABSetupInformation_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AdditionalRABSetupInformation_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AdditionalRABSetupInformation_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AdditionalRABSetupInformation_rncIpAddress_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AdditionalRABSetupInformation_rncIpAddress_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AdditionalRABSetupInformation_encoder(const AdditionalRABSetupInformation& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AdditionalRABSetupInformation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AdditionalRABSetupInformation_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AdditionalRABSetupInformation_decoder(OCTETSTRING& input_stream, AdditionalRABSetupInformation& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AdditionalRABSetupInformation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AdditionalRABSetupInformation_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AdditionalRABSetupInformation__List_encoder(const AdditionalRABSetupInformation__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AdditionalRABSetupInformation_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AdditionalRABSetupInformation__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AdditionalRABSetupInformation__List_decoder(OCTETSTRING& input_stream, AdditionalRABSetupInformation__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AdditionalRABSetupInformation_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AdditionalRABSetupInformation__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const PrivateExtension__gtpc__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.PrivateExtension_gtpc_List."); return other_value.val_ptr->n_elements == 0; } void PrivateExtension__gtpc_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PrivateExtension__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PrivateExtension__gtpc_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PrivateExtension__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PrivateExtension__gtpc_extensionValue_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PrivateExtension__gtpc_extensionValue_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PrivateExtension__gtpc_encoder(const PrivateExtension__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PrivateExtension_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PrivateExtension__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PrivateExtension__gtpc_decoder(OCTETSTRING& input_stream, PrivateExtension__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PrivateExtension_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PrivateExtension__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PrivateExtension__gtpc__List_encoder(const PrivateExtension__gtpc__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PrivateExtension_gtpc_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PrivateExtension__gtpc__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PrivateExtension__gtpc__List_decoder(OCTETSTRING& input_stream, PrivateExtension__gtpc__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PrivateExtension_gtpc_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PrivateExtension__gtpc__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SGSN__Number_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SGSN__Number_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SGSN__Number_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SGSN__Number_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SGSN__Number_sGSN__NumberValue_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SGSN__Number_sGSN__NumberValue_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SGSN__Number_encoder(const SGSN__Number& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SGSN_Number' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SGSN__Number_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SGSN__Number_decoder(OCTETSTRING& input_stream, SGSN__Number& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SGSN_Number' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SGSN__Number_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CommonFlags_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CommonFlags_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CommonFlags_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CommonFlags_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CommonFlags_encoder(const CommonFlags& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CommonFlags' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CommonFlags_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CommonFlags_decoder(OCTETSTRING& input_stream, CommonFlags& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CommonFlags' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CommonFlags_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void APN__Restriction_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(APN__Restriction_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER APN__Restriction_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(APN__Restriction_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void APN__Restriction_encoder(const APN__Restriction& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.APN_Restriction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(APN__Restriction_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER APN__Restriction_decoder(OCTETSTRING& input_stream, APN__Restriction& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.APN_Restriction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(APN__Restriction_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RATType_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RATType_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RATType_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RATType_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RATType_encoder(const RATType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RATType' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RATType_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RATType_decoder(OCTETSTRING& input_stream, RATType& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RATType' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RATType_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UserLocationInformation_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UserLocationInformation_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UserLocationInformation_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UserLocationInformation_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GeographicLocationCGI_encoder(const GeographicLocationCGI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GeographicLocationCGI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GeographicLocationCGI_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GeographicLocationCGI_decoder(OCTETSTRING& input_stream, GeographicLocationCGI& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GeographicLocationCGI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GeographicLocationCGI_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GeographicLocationSAI_encoder(const GeographicLocationSAI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GeographicLocationSAI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GeographicLocationSAI_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GeographicLocationSAI_decoder(OCTETSTRING& input_stream, GeographicLocationSAI& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GeographicLocationSAI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GeographicLocationSAI_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GeographicLocationRAI_encoder(const GeographicLocationRAI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GeographicLocationRAI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GeographicLocationRAI_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GeographicLocationRAI_decoder(OCTETSTRING& input_stream, GeographicLocationRAI& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GeographicLocationRAI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GeographicLocationRAI_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GeographicLocation__gtpc_encoder(const GeographicLocation__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GeographicLocation_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GeographicLocation__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GeographicLocation__gtpc_decoder(OCTETSTRING& input_stream, GeographicLocation__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GeographicLocation_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GeographicLocation__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UserLocationInformation_geographicLocation_encoder(const GeographicLocation__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GeographicLocation_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UserLocationInformation_geographicLocation_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UserLocationInformation_geographicLocation_decoder(OCTETSTRING& input_stream, GeographicLocation__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GeographicLocation_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UserLocationInformation_geographicLocation_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UserLocationInformation_encoder(const UserLocationInformation& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UserLocationInformation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UserLocationInformation_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UserLocationInformation_decoder(OCTETSTRING& input_stream, UserLocationInformation& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UserLocationInformation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UserLocationInformation_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MS__TimeZone_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MS__TimeZone_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MS__TimeZone_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MS__TimeZone_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MS__TimeZone_encoder(const MS__TimeZone& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MS_TimeZone' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MS__TimeZone_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MS__TimeZone_decoder(OCTETSTRING& input_stream, MS__TimeZone& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MS_TimeZone' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MS__TimeZone_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void IMEISV__gtpc_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(IMEISV__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER IMEISV__gtpc_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(IMEISV__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void IMEISV__gtpc_encoder(const IMEISV__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.IMEISV_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(IMEISV__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER IMEISV__gtpc_decoder(OCTETSTRING& input_stream, IMEISV__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.IMEISV_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(IMEISV__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CamelChargingInformationContainer_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CamelChargingInformationContainer_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CamelChargingInformationContainer_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CamelChargingInformationContainer_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CamelChargingInformationContainer_camelInformationPDP__IE_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CamelChargingInformationContainer_camelInformationPDP__IE_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CamelChargingInformationContainer_encoder(const CamelChargingInformationContainer& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CamelChargingInformationContainer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CamelChargingInformationContainer_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CamelChargingInformationContainer_decoder(OCTETSTRING& input_stream, CamelChargingInformationContainer& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CamelChargingInformationContainer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CamelChargingInformationContainer_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const MBMS__UE__Context__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.MBMS_UE_Context_List."); return other_value.val_ptr->n_elements == 0; } void MBMS__UE__ContextContainer_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__UE__ContextContainer_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__UE__ContextContainer_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__UE__ContextContainer_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__UE__ContextContainer_pdp__addressLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__UE__ContextContainer_pdp__addressLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__UE__ContextContainer_pdp__addressLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__UE__ContextContainer_pdp__addressLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__UE__ContextContainer_pdp__address_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__UE__ContextContainer_pdp__address_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__UE__ContextContainer_ggsn__addressControlPlaneLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__UE__ContextContainer_ggsn__addressControlPlaneLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__UE__ContextContainer_ggsn__addressControlPlaneLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__UE__ContextContainer_ggsn__addressControlPlaneLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__UE__ContextContainer_ggsn__addressControlPlane_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__UE__ContextContainer_ggsn__addressControlPlane_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__UE__ContextContainer_apnLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__UE__ContextContainer_apnLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__UE__ContextContainer_apnLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__UE__ContextContainer_apnLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__UE__ContextContainer_apn_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__UE__ContextContainer_apn_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__UE__ContextContainer_encoder(const MBMS__UE__ContextContainer& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_UE_ContextContainer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__UE__ContextContainer_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__UE__ContextContainer_decoder(OCTETSTRING& input_stream, MBMS__UE__ContextContainer& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_UE_ContextContainer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__UE__ContextContainer_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__UE__Context__List_encoder(const MBMS__UE__Context__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_UE_Context_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__UE__Context__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__UE__Context__List_decoder(OCTETSTRING& input_stream, MBMS__UE__Context__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_UE_Context_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__UE__Context__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TMGI__gtpc_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TMGI__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TMGI__gtpc_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TMGI__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void TMGI__gtpc_encoder(const TMGI__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TMGI_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(TMGI__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER TMGI__gtpc_decoder(OCTETSTRING& input_stream, TMGI__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.TMGI_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(TMGI__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__RoutingAddress_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__RoutingAddress_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__RoutingAddress_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__RoutingAddress_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__RoutingAddress_rIM__RoutingAddressValue_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__RoutingAddress_rIM__RoutingAddressValue_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__RoutingAddress_encoder(const RIM__RoutingAddress& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_RoutingAddress' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__RoutingAddress_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__RoutingAddress_decoder(OCTETSTRING& input_stream, RIM__RoutingAddress& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_RoutingAddress' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__RoutingAddress_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__ProtocolConfigurationOptions_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__ProtocolConfigurationOptions_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__ProtocolConfigurationOptions_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__ProtocolConfigurationOptions_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__ProtocolConfigurationOptions_mBMS__ProtocolConfigurationOptions_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__ProtocolConfigurationOptions_mBMS__ProtocolConfigurationOptions_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__ProtocolConfigurationOptions_encoder(const MBMS__ProtocolConfigurationOptions& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_ProtocolConfigurationOptions' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__ProtocolConfigurationOptions_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__ProtocolConfigurationOptions_decoder(OCTETSTRING& input_stream, MBMS__ProtocolConfigurationOptions& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_ProtocolConfigurationOptions' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__ProtocolConfigurationOptions_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__SessionDuration_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__SessionDuration_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__SessionDuration_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__SessionDuration_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__SessionDuration_encoder(const MBMS__SessionDuration& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_SessionDuration' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__SessionDuration_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__SessionDuration_decoder(OCTETSTRING& input_stream, MBMS__SessionDuration& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_SessionDuration' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__SessionDuration_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__ServiceArea_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__ServiceArea_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__ServiceArea_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__ServiceArea_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__ServiceArea_mBMS__ServiceAreaValue_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__ServiceArea_mBMS__ServiceAreaValue_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__ServiceArea_encoder(const MBMS__ServiceArea& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_ServiceArea' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__ServiceArea_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__ServiceArea_decoder(OCTETSTRING& input_stream, MBMS__ServiceArea& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_ServiceArea' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__ServiceArea_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SourceRNC__PDCP__ContextInfo_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SourceRNC__PDCP__ContextInfo_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SourceRNC__PDCP__ContextInfo_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SourceRNC__PDCP__ContextInfo_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SourceRNC__PDCP__ContextInfo_rRC__Container_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SourceRNC__PDCP__ContextInfo_rRC__Container_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SourceRNC__PDCP__ContextInfo_encoder(const SourceRNC__PDCP__ContextInfo& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SourceRNC_PDCP_ContextInfo' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SourceRNC__PDCP__ContextInfo_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SourceRNC__PDCP__ContextInfo_decoder(OCTETSTRING& input_stream, SourceRNC__PDCP__ContextInfo& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SourceRNC_PDCP_ContextInfo' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SourceRNC__PDCP__ContextInfo_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AdditionalTraceInfo_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AdditionalTraceInfo_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AdditionalTraceInfo_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AdditionalTraceInfo_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AdditionalTraceInfo_encoder(const AdditionalTraceInfo& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AdditionalTraceInfo' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AdditionalTraceInfo_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AdditionalTraceInfo_decoder(OCTETSTRING& input_stream, AdditionalTraceInfo& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AdditionalTraceInfo' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AdditionalTraceInfo_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void HopCounter__gtpc_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(HopCounter__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER HopCounter__gtpc_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(HopCounter__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void HopCounter__gtpc_hopCounter_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(INTEGER_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER HopCounter__gtpc_hopCounter_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(INTEGER_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void HopCounter__gtpc_encoder(const HopCounter__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.HopCounter_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(HopCounter__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER HopCounter__gtpc_decoder(OCTETSTRING& input_stream, HopCounter__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.HopCounter_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(HopCounter__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Selected__PLMN__ID_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Selected__PLMN__ID_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Selected__PLMN__ID_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Selected__PLMN__ID_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Selected__PLMN__ID_encoder(const Selected__PLMN__ID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Selected_PLMN_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Selected__PLMN__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Selected__PLMN__ID_decoder(OCTETSTRING& input_stream, Selected__PLMN__ID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Selected_PLMN_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Selected__PLMN__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__SessionIdentifier_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__SessionIdentifier_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__SessionIdentifier_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__SessionIdentifier_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__SessionIdentifier_encoder(const MBMS__SessionIdentifier& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_SessionIdentifier' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__SessionIdentifier_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__SessionIdentifier_decoder(OCTETSTRING& input_stream, MBMS__SessionIdentifier& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_SessionIdentifier' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__SessionIdentifier_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__2G__3G__Indicator_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__2G__3G__Indicator_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__2G__3G__Indicator_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__2G__3G__Indicator_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__2G__3G__Indicator_encoder(const MBMS__2G__3G__Indicator& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_2G_3G_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__2G__3G__Indicator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__2G__3G__Indicator_decoder(OCTETSTRING& input_stream, MBMS__2G__3G__Indicator& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_2G_3G_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__2G__3G__Indicator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Enhanced__NSAPI_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Enhanced__NSAPI_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Enhanced__NSAPI_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Enhanced__NSAPI_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Enhanced__NSAPI_encoder(const Enhanced__NSAPI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Enhanced_NSAPI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Enhanced__NSAPI_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Enhanced__NSAPI_decoder(OCTETSTRING& input_stream, Enhanced__NSAPI& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Enhanced_NSAPI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Enhanced__NSAPI_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AdditionalMBMSTraceInfo_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AdditionalMBMSTraceInfo_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AdditionalMBMSTraceInfo_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AdditionalMBMSTraceInfo_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void AdditionalMBMSTraceInfo_encoder(const AdditionalMBMSTraceInfo& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AdditionalMBMSTraceInfo' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(AdditionalMBMSTraceInfo_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER AdditionalMBMSTraceInfo_decoder(OCTETSTRING& input_stream, AdditionalMBMSTraceInfo& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.AdditionalMBMSTraceInfo' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(AdditionalMBMSTraceInfo_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__SessionRepetitionNumber_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__SessionRepetitionNumber_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__SessionRepetitionNumber_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__SessionRepetitionNumber_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__SessionRepetitionNumber_encoder(const MBMS__SessionRepetitionNumber& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_SessionRepetitionNumber' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__SessionRepetitionNumber_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__SessionRepetitionNumber_decoder(OCTETSTRING& input_stream, MBMS__SessionRepetitionNumber& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_SessionRepetitionNumber' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__SessionRepetitionNumber_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__TimeToDataTransfer_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__TimeToDataTransfer_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__TimeToDataTransfer_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__TimeToDataTransfer_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__TimeToDataTransfer_encoder(const MBMS__TimeToDataTransfer& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_TimeToDataTransfer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__TimeToDataTransfer_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__TimeToDataTransfer_decoder(OCTETSTRING& input_stream, MBMS__TimeToDataTransfer& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_TimeToDataTransfer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__TimeToDataTransfer_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void BSS__Container_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(BSS__Container_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER BSS__Container_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(BSS__Container_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void BSS__Container_bSS__Container_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER BSS__Container_bSS__Container_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void BSS__Container_encoder(const BSS__Container& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.BSS_Container' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(BSS__Container_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER BSS__Container_decoder(OCTETSTRING& input_stream, BSS__Container& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.BSS_Container' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(BSS__Container_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RoutingAreaIdentificationV__gtpc_encoder(const RoutingAreaIdentificationV__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RoutingAreaIdentificationV_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RoutingAreaIdentificationV__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RoutingAreaIdentificationV__gtpc_decoder(OCTETSTRING& input_stream, RoutingAreaIdentificationV__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RoutingAreaIdentificationV_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RoutingAreaIdentificationV__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RNC__Identifier__gtpc_rNC__ID_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RNC__Identifier__gtpc_rNC__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RNC__Identifier__gtpc_rNC__ID_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RNC__Identifier__gtpc_rNC__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RNC__Identifier__gtpc_spare_encoder(const HEXSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `hexstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RNC__Identifier__gtpc_spare_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RNC__Identifier__gtpc_spare_decoder(OCTETSTRING& input_stream, HEXSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `hexstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RNC__Identifier__gtpc_spare_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RNC__Identifier__gtpc_encoder(const RNC__Identifier__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RNC_Identifier_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RNC__Identifier__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RNC__Identifier__gtpc_decoder(OCTETSTRING& input_stream, RNC__Identifier__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RNC_Identifier_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RNC__Identifier__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Cell__ID__or__RNC__ID_encoder(const Cell__ID__or__RNC__ID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Cell_ID_or_RNC_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Cell__ID__or__RNC__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Cell__ID__or__RNC__ID_decoder(OCTETSTRING& input_stream, Cell__ID__or__RNC__ID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Cell_ID_or_RNC_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Cell__ID__or__RNC__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Cell__Identification__gtpc_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Cell__Identification__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Cell__Identification__gtpc_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Cell__Identification__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Cell__Identification__gtpc_source__Cell__ID__or__RNC__ID_encoder(const Cell__ID__or__RNC__ID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Cell_ID_or_RNC_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Cell__Identification__gtpc_source__Cell__ID__or__RNC__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Cell__Identification__gtpc_source__Cell__ID__or__RNC__ID_decoder(OCTETSTRING& input_stream, Cell__ID__or__RNC__ID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Cell_ID_or_RNC_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Cell__Identification__gtpc_source__Cell__ID__or__RNC__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Cell__Identification__gtpc_encoder(const Cell__Identification__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Cell_Identification_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Cell__Identification__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Cell__Identification__gtpc_decoder(OCTETSTRING& input_stream, Cell__Identification__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Cell_Identification_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Cell__Identification__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const PDU__Numbers__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.PDU_Numbers_List."); return other_value.val_ptr->n_elements == 0; } void PDU__Numbers_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__Numbers_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__Numbers_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__Numbers_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__Numbers_encoder(const PDU__Numbers& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_Numbers' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__Numbers_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__Numbers_decoder(OCTETSTRING& input_stream, PDU__Numbers& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_Numbers' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__Numbers_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__Numbers__List_encoder(const PDU__Numbers__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_Numbers_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__Numbers__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__Numbers__List_decoder(OCTETSTRING& input_stream, PDU__Numbers__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_Numbers_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__Numbers__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void BSSGP__Cause__gtpc_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(BSSGP__Cause__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER BSSGP__Cause__gtpc_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(BSSGP__Cause__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void BSSGP__Cause__gtpc_encoder(const BSSGP__Cause__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.BSSGP_Cause_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(BSSGP__Cause__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER BSSGP__Cause__gtpc_decoder(OCTETSTRING& input_stream, BSSGP__Cause__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.BSSGP_Cause_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(BSSGP__Cause__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RequiredMBMS__BearerCapabilities_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RequiredMBMS__BearerCapabilities_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RequiredMBMS__BearerCapabilities_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RequiredMBMS__BearerCapabilities_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RequiredMBMS__BearerCapabilities_reqMBMS__BearerCapValue_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RequiredMBMS__BearerCapabilities_reqMBMS__BearerCapValue_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RequiredMBMS__BearerCapabilities_encoder(const RequiredMBMS__BearerCapabilities& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RequiredMBMS_BearerCapabilities' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RequiredMBMS__BearerCapabilities_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RequiredMBMS__BearerCapabilities_decoder(OCTETSTRING& input_stream, RequiredMBMS__BearerCapabilities& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RequiredMBMS_BearerCapabilities' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RequiredMBMS__BearerCapabilities_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__RoutingAddress__Discriminator_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__RoutingAddress__Discriminator_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__RoutingAddress__Discriminator_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__RoutingAddress__Discriminator_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RIM__RoutingAddress__Discriminator_encoder(const RIM__RoutingAddress__Discriminator& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_RoutingAddress_Discriminator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RIM__RoutingAddress__Discriminator_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RIM__RoutingAddress__Discriminator_decoder(OCTETSTRING& input_stream, RIM__RoutingAddress__Discriminator& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RIM_RoutingAddress_Discriminator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RIM__RoutingAddress__Discriminator_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Single__PFI__gtpc_encoder(const Single__PFI__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Single_PFI_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Single__PFI__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Single__PFI__gtpc_decoder(OCTETSTRING& input_stream, Single__PFI__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Single_PFI_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Single__PFI__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const Multiple__PFIs__gtpc& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.Multiple_PFIs_gtpc."); return other_value.val_ptr->n_elements == 0; } void Multiple__PFIs__gtpc_encoder(const Multiple__PFIs__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Multiple_PFIs_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Multiple__PFIs__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Multiple__PFIs__gtpc_decoder(OCTETSTRING& input_stream, Multiple__PFIs__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Multiple_PFIs_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Multiple__PFIs__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ListOfSetupPFCsValue__gtpc_number__of__PFCs_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ListOfSetupPFCsValue__gtpc_number__of__PFCs_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ListOfSetupPFCsValue__gtpc_number__of__PFCs_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ListOfSetupPFCsValue__gtpc_number__of__PFCs_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ListOfSetupPFCsValue__gtpc_encoder(const ListOfSetupPFCsValue__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ListOfSetupPFCsValue_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ListOfSetupPFCsValue__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ListOfSetupPFCsValue__gtpc_decoder(OCTETSTRING& input_stream, ListOfSetupPFCsValue__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ListOfSetupPFCsValue_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ListOfSetupPFCsValue__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ListOfSetupPFCs__gtpc_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ListOfSetupPFCs__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ListOfSetupPFCs__gtpc_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ListOfSetupPFCs__gtpc_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ListOfSetupPFCs__gtpc_encoder(const ListOfSetupPFCs__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ListOfSetupPFCs_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ListOfSetupPFCs__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ListOfSetupPFCs__gtpc_decoder(OCTETSTRING& input_stream, ListOfSetupPFCs__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ListOfSetupPFCs_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ListOfSetupPFCs__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const PS__HandoverXIDParameters__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.PS_HandoverXIDParameters_List."); return other_value.val_ptr->n_elements == 0; } void PS__HandoverXIDParameters_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PS__HandoverXIDParameters_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PS__HandoverXIDParameters_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PS__HandoverXIDParameters_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PS__HandoverXIDParameters_xID__ParametersLength_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PS__HandoverXIDParameters_xID__ParametersLength_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PS__HandoverXIDParameters_xID__ParametersLength_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PS__HandoverXIDParameters_xID__ParametersLength_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const XID__Information__GTPC& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.XID_Information_GTPC."); return other_value.val_ptr->n_elements == 0; } void XID__GTPC_xl_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(XID__GTPC_xl_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER XID__GTPC_xl_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(XID__GTPC_xl_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void XID__GTPC_typefield_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(XID__GTPC_typefield_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER XID__GTPC_typefield_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(XID__GTPC_typefield_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void XID__length__GTPC_short__len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(XID__length__GTPC_short__len_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER XID__length__GTPC_short__len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(XID__length__GTPC_short__len_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void XID__length__GTPC_long__len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(XID__length__GTPC_long__len_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER XID__length__GTPC_long__len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(XID__length__GTPC_long__len_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void XID__length__GTPC_encoder(const XID__length__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_length_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(XID__length__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER XID__length__GTPC_decoder(OCTETSTRING& input_stream, XID__length__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_length_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(XID__length__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void XID__GTPC_xID__length_encoder(const XID__length__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_length_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(XID__GTPC_xID__length_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER XID__GTPC_xID__length_decoder(OCTETSTRING& input_stream, XID__length__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_length_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(XID__GTPC_xID__length_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Version__GTPC_version__value_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Version__GTPC_version__value_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Version__GTPC_version__value_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Version__GTPC_version__value_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Version__GTPC_encoder(const Version__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Version_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Version__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Version__GTPC_decoder(OCTETSTRING& input_stream, Version__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Version_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Version__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void IOV__UI__GTPC_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(IOV__UI__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER IOV__UI__GTPC_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(IOV__UI__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void IOV__I__GTPC_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(IOV__I__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER IOV__I__GTPC_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(IOV__I__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void T200__GTPC_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(T200__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER T200__GTPC_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(T200__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void T200__GTPC_t200Value_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(T200__GTPC_t200Value_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER T200__GTPC_t200Value_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(T200__GTPC_t200Value_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void T200__GTPC_encoder(const T200__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.T200_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(T200__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER T200__GTPC_decoder(OCTETSTRING& input_stream, T200__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.T200_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(T200__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void N200__GTPC_retransmissions_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(N200__GTPC_retransmissions_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER N200__GTPC_retransmissions_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(N200__GTPC_retransmissions_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void N200__GTPC_encoder(const N200__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.N200_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(N200__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER N200__GTPC_decoder(OCTETSTRING& input_stream, N200__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.N200_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(N200__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void N201__U__GTPC_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(N201__U__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER N201__U__GTPC_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(N201__U__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void N201__U__GTPC_n201UValue_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(N201__U__GTPC_n201UValue_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER N201__U__GTPC_n201UValue_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(N201__U__GTPC_n201UValue_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void N201__U__GTPC_encoder(const N201__U__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.N201_U_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(N201__U__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER N201__U__GTPC_decoder(OCTETSTRING& input_stream, N201__U__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.N201_U_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(N201__U__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void N201__I__GTPC_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(N201__I__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER N201__I__GTPC_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(N201__I__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void N201__I__GTPC_n201IValue_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(N201__I__GTPC_n201IValue_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER N201__I__GTPC_n201IValue_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(N201__I__GTPC_n201IValue_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void N201__I__GTPC_encoder(const N201__I__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.N201_I_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(N201__I__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER N201__I__GTPC_decoder(OCTETSTRING& input_stream, N201__I__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.N201_I_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(N201__I__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MD__GTPC_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MD__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MD__GTPC_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MD__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MD__GTPC_mDValue_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MD__GTPC_mDValue_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MD__GTPC_mDValue_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MD__GTPC_mDValue_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MD__GTPC_encoder(const MD__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MD_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MD__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MD__GTPC_decoder(OCTETSTRING& input_stream, MD__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MD_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MD__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MU__GTPC_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MU__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MU__GTPC_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MU__GTPC_spare_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MU__GTPC_mUValue_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MU__GTPC_mUValue_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MU__GTPC_mUValue_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MU__GTPC_mUValue_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MU__GTPC_encoder(const MU__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MU_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MU__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MU__GTPC_decoder(OCTETSTRING& input_stream, MU__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MU_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MU__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void KD__GTPC_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(KD__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER KD__GTPC_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(KD__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void KU__GTPC_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(KU__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER KU__GTPC_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(KU__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void L3param__GTPC_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER L3param__GTPC_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Reset__LLC__GTPC_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Reset__LLC__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Reset__LLC__GTPC_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Reset__LLC__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void XID__Data__GTPC_encoder(const XID__Data__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_Data_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(XID__Data__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER XID__Data__GTPC_decoder(OCTETSTRING& input_stream, XID__Data__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_Data_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(XID__Data__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void XID__GTPC_xID__Data_encoder(const XID__Data__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_Data_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(XID__GTPC_xID__Data_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER XID__GTPC_xID__Data_decoder(OCTETSTRING& input_stream, XID__Data__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_Data_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(XID__GTPC_xID__Data_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void XID__GTPC_encoder(const XID__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(XID__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER XID__GTPC_decoder(OCTETSTRING& input_stream, XID__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(XID__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void XID__Information__GTPC_encoder(const XID__Information__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_Information_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(XID__Information__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER XID__Information__GTPC_decoder(OCTETSTRING& input_stream, XID__Information__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.XID_Information_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(XID__Information__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PS__HandoverXIDParameters_encoder(const PS__HandoverXIDParameters& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PS_HandoverXIDParameters' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PS__HandoverXIDParameters_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PS__HandoverXIDParameters_decoder(OCTETSTRING& input_stream, PS__HandoverXIDParameters& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PS_HandoverXIDParameters' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PS__HandoverXIDParameters_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PS__HandoverXIDParameters__List_encoder(const PS__HandoverXIDParameters__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PS_HandoverXIDParameters_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PS__HandoverXIDParameters__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PS__HandoverXIDParameters__List_decoder(OCTETSTRING& input_stream, PS__HandoverXIDParameters__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PS_HandoverXIDParameters_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PS__HandoverXIDParameters__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MS__InfoChangeReportingAction_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MS__InfoChangeReportingAction_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MS__InfoChangeReportingAction_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MS__InfoChangeReportingAction_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MS__InfoChangeReportingAction_encoder(const MS__InfoChangeReportingAction& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MS_InfoChangeReportingAction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MS__InfoChangeReportingAction_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MS__InfoChangeReportingAction_decoder(OCTETSTRING& input_stream, MS__InfoChangeReportingAction& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MS_InfoChangeReportingAction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MS__InfoChangeReportingAction_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void DirectTunnelFlags_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(DirectTunnelFlags_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER DirectTunnelFlags_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(DirectTunnelFlags_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void DirectTunnelFlags_encoder(const DirectTunnelFlags& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.DirectTunnelFlags' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(DirectTunnelFlags_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER DirectTunnelFlags_decoder(OCTETSTRING& input_stream, DirectTunnelFlags& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.DirectTunnelFlags' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(DirectTunnelFlags_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CorrelationID_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CorrelationID_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CorrelationID_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CorrelationID_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CorrelationID_encoder(const CorrelationID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CorrelationID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CorrelationID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CorrelationID_decoder(OCTETSTRING& input_stream, CorrelationID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CorrelationID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CorrelationID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void BearerControlMode_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(BearerControlMode_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER BearerControlMode_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(BearerControlMode_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void BearerControlMode_encoder(const BearerControlMode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.BearerControlMode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(BearerControlMode_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER BearerControlMode_decoder(OCTETSTRING& input_stream, BearerControlMode& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.BearerControlMode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(BearerControlMode_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__FlowID_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__FlowID_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__FlowID_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__FlowID_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__FlowID_mBMS__FlowIDValue_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__FlowID_mBMS__FlowIDValue_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__FlowID_encoder(const MBMS__FlowID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_FlowID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__FlowID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__FlowID_decoder(OCTETSTRING& input_stream, MBMS__FlowID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_FlowID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__FlowID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__IPMulticastDistribution_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__IPMulticastDistribution_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__IPMulticastDistribution_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__IPMulticastDistribution_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GSNAddress_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GSNAddress_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GSNAddress_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GSNAddress_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GSNAddress_encoder(const GSNAddress& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GSNAddress' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GSNAddress_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GSNAddress_decoder(OCTETSTRING& input_stream, GSNAddress& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GSNAddress' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GSNAddress_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__IPMulticastDistribution_encoder(const MBMS__IPMulticastDistribution& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_IPMulticastDistribution' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__IPMulticastDistribution_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__IPMulticastDistribution_decoder(OCTETSTRING& input_stream, MBMS__IPMulticastDistribution& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_IPMulticastDistribution' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__IPMulticastDistribution_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__DistributionAcknowledgement_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__DistributionAcknowledgement_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__DistributionAcknowledgement_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__DistributionAcknowledgement_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMS__DistributionAcknowledgement_encoder(const MBMS__DistributionAcknowledgement& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_DistributionAcknowledgement' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMS__DistributionAcknowledgement_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMS__DistributionAcknowledgement_decoder(OCTETSTRING& input_stream, MBMS__DistributionAcknowledgement& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMS_DistributionAcknowledgement' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMS__DistributionAcknowledgement_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ReliableInterRATHandoverInfo_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ReliableInterRATHandoverInfo_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ReliableInterRATHandoverInfo_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ReliableInterRATHandoverInfo_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ReliableInterRATHandoverInfo_encoder(const ReliableInterRATHandoverInfo& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ReliableInterRATHandoverInfo' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ReliableInterRATHandoverInfo_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ReliableInterRATHandoverInfo_decoder(OCTETSTRING& input_stream, ReliableInterRATHandoverInfo& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ReliableInterRATHandoverInfo' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ReliableInterRATHandoverInfo_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RFSP__Index_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RFSP__Index_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RFSP__Index_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RFSP__Index_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RFSP__Index_encoder(const RFSP__Index& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RFSP_Index' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RFSP__Index_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RFSP__Index_decoder(OCTETSTRING& input_stream, RFSP__Index& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RFSP_Index' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RFSP__Index_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const FullyQualifiedDomainName__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.FullyQualifiedDomainName_List."); return other_value.val_ptr->n_elements == 0; } void FullyQualifiedDomainName_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(FullyQualifiedDomainName_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER FullyQualifiedDomainName_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(FullyQualifiedDomainName_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void FullyQualifiedDomainName_fQDN__Value_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER FullyQualifiedDomainName_fQDN__Value_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void FullyQualifiedDomainName_encoder(const FullyQualifiedDomainName& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.FullyQualifiedDomainName' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(FullyQualifiedDomainName_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER FullyQualifiedDomainName_decoder(OCTETSTRING& input_stream, FullyQualifiedDomainName& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.FullyQualifiedDomainName' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(FullyQualifiedDomainName_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void FullyQualifiedDomainName__List_encoder(const FullyQualifiedDomainName__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.FullyQualifiedDomainName_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(FullyQualifiedDomainName__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER FullyQualifiedDomainName__List_decoder(OCTETSTRING& input_stream, FullyQualifiedDomainName__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.FullyQualifiedDomainName_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(FullyQualifiedDomainName__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EvolvedAllocationRetentionPriorityI_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EvolvedAllocationRetentionPriorityI_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EvolvedAllocationRetentionPriorityI_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EvolvedAllocationRetentionPriorityI_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EvolvedAllocationRetentionPriorityI_pL_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EvolvedAllocationRetentionPriorityI_pL_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EvolvedAllocationRetentionPriorityI_pL_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EvolvedAllocationRetentionPriorityI_pL_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EvolvedAllocationRetentionPriorityI_encoder(const EvolvedAllocationRetentionPriorityI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EvolvedAllocationRetentionPriorityI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EvolvedAllocationRetentionPriorityI_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EvolvedAllocationRetentionPriorityI_decoder(OCTETSTRING& input_stream, EvolvedAllocationRetentionPriorityI& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EvolvedAllocationRetentionPriorityI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EvolvedAllocationRetentionPriorityI_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const EvolvedAllocationRetentionPriorityII__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.EvolvedAllocationRetentionPriorityII_List."); return other_value.val_ptr->n_elements == 0; } void EvolvedAllocationRetentionPriorityII_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EvolvedAllocationRetentionPriorityII_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EvolvedAllocationRetentionPriorityII_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EvolvedAllocationRetentionPriorityII_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EvolvedAllocationRetentionPriorityII_pL_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EvolvedAllocationRetentionPriorityII_pL_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EvolvedAllocationRetentionPriorityII_pL_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EvolvedAllocationRetentionPriorityII_pL_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EvolvedAllocationRetentionPriorityII_encoder(const EvolvedAllocationRetentionPriorityII& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EvolvedAllocationRetentionPriorityII' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EvolvedAllocationRetentionPriorityII_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EvolvedAllocationRetentionPriorityII_decoder(OCTETSTRING& input_stream, EvolvedAllocationRetentionPriorityII& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EvolvedAllocationRetentionPriorityII' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EvolvedAllocationRetentionPriorityII_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EvolvedAllocationRetentionPriorityII__List_encoder(const EvolvedAllocationRetentionPriorityII__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EvolvedAllocationRetentionPriorityII_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EvolvedAllocationRetentionPriorityII__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EvolvedAllocationRetentionPriorityII__List_decoder(OCTETSTRING& input_stream, EvolvedAllocationRetentionPriorityII__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EvolvedAllocationRetentionPriorityII_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EvolvedAllocationRetentionPriorityII__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ExtendedCommonFlags_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ExtendedCommonFlags_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ExtendedCommonFlags_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ExtendedCommonFlags_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ExtendedCommonFlags_encoder(const ExtendedCommonFlags& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ExtendedCommonFlags' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ExtendedCommonFlags_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ExtendedCommonFlags_decoder(OCTETSTRING& input_stream, ExtendedCommonFlags& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ExtendedCommonFlags' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ExtendedCommonFlags_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UserCSGInformation_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UserCSGInformation_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UserCSGInformation_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UserCSGInformation_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UserCSGInformation_spare1_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UserCSGInformation_spare1_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UserCSGInformation_spare1_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UserCSGInformation_spare1_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UserCSGInformation_cSG__ID_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UserCSGInformation_cSG__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UserCSGInformation_cSG__ID_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UserCSGInformation_cSG__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UserCSGInformation_accessMode_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UserCSGInformation_accessMode_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UserCSGInformation_accessMode_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UserCSGInformation_accessMode_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UserCSGInformation_encoder(const UserCSGInformation& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UserCSGInformation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UserCSGInformation_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UserCSGInformation_decoder(OCTETSTRING& input_stream, UserCSGInformation& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UserCSGInformation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UserCSGInformation_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CSGInfoReportingAction_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CSGInfoReportingAction_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CSGInfoReportingAction_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CSGInfoReportingAction_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CSGInfoReportingAction_encoder(const CSGInfoReportingAction& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CSGInfoReportingAction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CSGInfoReportingAction_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CSGInfoReportingAction_decoder(OCTETSTRING& input_stream, CSGInfoReportingAction& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CSGInfoReportingAction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CSGInfoReportingAction_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CSG__Id_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CSG__Id_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CSG__Id_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CSG__Id_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CSG__Id_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CSG__Id_spare_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CSG__Id_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CSG__Id_spare_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CSG__Id_cSG__ID_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CSG__Id_cSG__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CSG__Id_cSG__ID_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CSG__Id_cSG__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CSG__Id_encoder(const CSG__Id& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CSG_Id' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CSG__Id_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CSG__Id_decoder(OCTETSTRING& input_stream, CSG__Id& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CSG_Id' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CSG__Id_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CSG__MembershipIndication_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CSG__MembershipIndication_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CSG__MembershipIndication_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CSG__MembershipIndication_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CSG__MembershipIndication_encoder(const CSG__MembershipIndication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CSG_MembershipIndication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CSG__MembershipIndication_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CSG__MembershipIndication_decoder(OCTETSTRING& input_stream, CSG__MembershipIndication& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CSG_MembershipIndication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CSG__MembershipIndication_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void APN__AMBR_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(APN__AMBR_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER APN__AMBR_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(APN__AMBR_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void APN__AMBR_encoder(const APN__AMBR& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.APN_AMBR' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(APN__AMBR_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER APN__AMBR_decoder(OCTETSTRING& input_stream, APN__AMBR& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.APN_AMBR' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(APN__AMBR_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UE__Network__Capability_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UE__Network__Capability_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UE__Network__Capability_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UE__Network__Capability_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UE__Network__Capability_ue__network__capability_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UE__Network__Capability_ue__network__capability_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UE__Network__Capability_encoder(const UE__Network__Capability& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UE_Network_Capability' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UE__Network__Capability_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UE__Network__Capability_decoder(OCTETSTRING& input_stream, UE__Network__Capability& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UE_Network_Capability' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UE__Network__Capability_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UE__AMBR_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UE__AMBR_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UE__AMBR_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UE__AMBR_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UE__AMBR_encoder(const UE__AMBR& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UE_AMBR' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UE__AMBR_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UE__AMBR_decoder(OCTETSTRING& input_stream, UE__AMBR& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UE_AMBR' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UE__AMBR_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void APN__AMBR__NSAPI_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(APN__AMBR__NSAPI_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER APN__AMBR__NSAPI_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(APN__AMBR__NSAPI_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void APN__AMBR__NSAPI_encoder(const APN__AMBR__NSAPI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.APN_AMBR_NSAPI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(APN__AMBR__NSAPI_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER APN__AMBR__NSAPI_decoder(OCTETSTRING& input_stream, APN__AMBR__NSAPI& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.APN_AMBR_NSAPI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(APN__AMBR__NSAPI_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GGSN__BackOffTime_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GGSN__BackOffTime_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GGSN__BackOffTime_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GGSN__BackOffTime_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GGSN__BackOffTime_explicitly__specified_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GGSN__BackOffTime_explicitly__specified_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GGSN__BackOffTime_encoder(const GGSN__BackOffTime& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GGSN_BackOffTime' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GGSN__BackOffTime_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GGSN__BackOffTime_decoder(OCTETSTRING& input_stream, GGSN__BackOffTime& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GGSN_BackOffTime' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GGSN__BackOffTime_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SignallingPriorityIndication_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SignallingPriorityIndication_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SignallingPriorityIndication_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SignallingPriorityIndication_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SignallingPriorityIndication_explicitly__specified_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SignallingPriorityIndication_explicitly__specified_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SignallingPriorityIndication_encoder(const SignallingPriorityIndication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SignallingPriorityIndication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SignallingPriorityIndication_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SignallingPriorityIndication_decoder(OCTETSTRING& input_stream, SignallingPriorityIndication& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SignallingPriorityIndication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SignallingPriorityIndication_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SignallingPriorityIndication__NSAPI_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SignallingPriorityIndication__NSAPI_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SignallingPriorityIndication__NSAPI_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SignallingPriorityIndication__NSAPI_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SignallingPriorityIndication__NSAPI_explicitly__specified_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SignallingPriorityIndication__NSAPI_explicitly__specified_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SignallingPriorityIndication__NSAPI_encoder(const SignallingPriorityIndication__NSAPI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SignallingPriorityIndication_NSAPI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SignallingPriorityIndication__NSAPI_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SignallingPriorityIndication__NSAPI_decoder(OCTETSTRING& input_stream, SignallingPriorityIndication__NSAPI& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SignallingPriorityIndication_NSAPI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SignallingPriorityIndication__NSAPI_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Higher__Bitrates__Than__16Mbps__Flag_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Higher__Bitrates__Than__16Mbps__Flag_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Higher__Bitrates__Than__16Mbps__Flag_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Higher__Bitrates__Than__16Mbps__Flag_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Higher__Bitrates__Than__16Mbps__Flag_encoder(const Higher__Bitrates__Than__16Mbps__Flag& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Higher_Bitrates_Than_16Mbps_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Higher__Bitrates__Than__16Mbps__Flag_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Higher__Bitrates__Than__16Mbps__Flag_decoder(OCTETSTRING& input_stream, Higher__Bitrates__Than__16Mbps__Flag& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Higher_Bitrates_Than_16Mbps_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Higher__Bitrates__Than__16Mbps__Flag_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__MM__Context_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SRVCC__MM__Context_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__MM__Context_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SRVCC__MM__Context_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__MM__Context_mobile__station__classmark2__len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SRVCC__MM__Context_mobile__station__classmark2__len_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__MM__Context_mobile__station__classmark2__len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SRVCC__MM__Context_mobile__station__classmark2__len_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__MM__Context_mobile__station__classmark2_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__MM__Context_mobile__station__classmark2_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__MM__Context_mobile__station__classmark3__len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SRVCC__MM__Context_mobile__station__classmark3__len_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__MM__Context_mobile__station__classmark3__len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SRVCC__MM__Context_mobile__station__classmark3__len_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__MM__Context_mobile__station__classmark3_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__MM__Context_mobile__station__classmark3_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__MM__Context_supported__codec__list__len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SRVCC__MM__Context_supported__codec__list__len_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__MM__Context_supported__codec__list__len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SRVCC__MM__Context_supported__codec__list__len_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__MM__Context_supported__codec__list_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__MM__Context_supported__codec__list_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__MM__Context_explicitly__specified_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__MM__Context_explicitly__specified_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__MM__Context_encoder(const SRVCC__MM__Context& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SRVCC_MM_Context' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SRVCC__MM__Context_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__MM__Context_decoder(OCTETSTRING& input_stream, SRVCC__MM__Context& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SRVCC_MM_Context' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SRVCC__MM__Context_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__Flags_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SRVCC__Flags_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__Flags_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SRVCC__Flags_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__Flags_explicitly__specified_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__Flags_explicitly__specified_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SRVCC__Flags_encoder(const SRVCC__Flags& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SRVCC_Flags' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SRVCC__Flags_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SRVCC__Flags_decoder(OCTETSTRING& input_stream, SRVCC__Flags& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SRVCC_Flags' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SRVCC__Flags_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void STN__SR_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(STN__SR_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER STN__SR_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(STN__SR_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Digits_encoder(const Digits& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Digits' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Digits_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Digits_decoder(OCTETSTRING& input_stream, Digits& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Digits' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Digits_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void STN__SR_encoder(const STN__SR& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.STN_SR' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(STN__SR_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER STN__SR_decoder(OCTETSTRING& input_stream, STN__SR& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.STN_SR' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(STN__SR_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void C__MSISDN_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(C__MSISDN_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER C__MSISDN_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(C__MSISDN_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void C__MSISDN_msisdn_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER C__MSISDN_msisdn_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void C__MSISDN_encoder(const C__MSISDN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.C_MSISDN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(C__MSISDN_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER C__MSISDN_decoder(OCTETSTRING& input_stream, C__MSISDN& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.C_MSISDN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(C__MSISDN_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Extended__RANAP__Cause_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Extended__RANAP__Cause_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Extended__RANAP__Cause_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Extended__RANAP__Cause_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Extended__RANAP__Cause_extended__ranap__cause_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Extended__RANAP__Cause_extended__ranap__cause_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Extended__RANAP__Cause_extended__ranap__cause_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Extended__RANAP__Cause_extended__ranap__cause_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Extended__RANAP__Cause_explicitly__specified_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Extended__RANAP__Cause_explicitly__specified_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void Extended__RANAP__Cause_encoder(const Extended__RANAP__Cause& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Extended_RANAP_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(Extended__RANAP__Cause_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER Extended__RANAP__Cause_decoder(OCTETSTRING& input_stream, Extended__RANAP__Cause& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.Extended_RANAP_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(Extended__RANAP__Cause_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ENodeB__ID_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ENodeB__ID_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ENodeB__ID_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ENodeB__ID_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void HomeENodeB__ID_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(HomeENodeB__ID_spare_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER HomeENodeB__ID_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(HomeENodeB__ID_spare_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void HomeENodeB__ID_homeENodeB__ID_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(HomeENodeB__ID_homeENodeB__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER HomeENodeB__ID_homeENodeB__ID_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(HomeENodeB__ID_homeENodeB__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void HomeENodeB__ID_encoder(const HomeENodeB__ID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.HomeENodeB_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(HomeENodeB__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER HomeENodeB__ID_decoder(OCTETSTRING& input_stream, HomeENodeB__ID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.HomeENodeB_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(HomeENodeB__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MacroENodeB__ID_spare_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MacroENodeB__ID_spare_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MacroENodeB__ID_spare_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MacroENodeB__ID_spare_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MacroENodeB__ID_macroENodeB__ID_encoder(const BITSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MacroENodeB__ID_macroENodeB__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MacroENodeB__ID_macroENodeB__ID_decoder(OCTETSTRING& input_stream, BITSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `bitstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MacroENodeB__ID_macroENodeB__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MacroENodeB__ID_encoder(const MacroENodeB__ID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MacroENodeB_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MacroENodeB__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MacroENodeB__ID_decoder(OCTETSTRING& input_stream, MacroENodeB__ID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MacroENodeB_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MacroENodeB__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ENodeB__IDs_encoder(const ENodeB__IDs& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ENodeB_IDs' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ENodeB__IDs_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ENodeB__IDs_decoder(OCTETSTRING& input_stream, ENodeB__IDs& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ENodeB_IDs' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ENodeB__IDs_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ENodeB__ID_encoder(const ENodeB__ID& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ENodeB_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ENodeB__ID_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ENodeB__ID_decoder(OCTETSTRING& input_stream, ENodeB__ID& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ENodeB_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ENodeB__ID_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SelectionMode__NSAPI_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SelectionMode__NSAPI_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SelectionMode__NSAPI_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SelectionMode__NSAPI_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SelectionMode__NSAPI_encoder(const SelectionMode__NSAPI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SelectionMode_NSAPI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SelectionMode__NSAPI_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SelectionMode__NSAPI_decoder(OCTETSTRING& input_stream, SelectionMode__NSAPI& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SelectionMode_NSAPI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SelectionMode__NSAPI_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ULI__Timestamp_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ULI__Timestamp_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ULI__Timestamp_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ULI__Timestamp_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ULI__Timestamp_explicitly__specified_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ULI__Timestamp_explicitly__specified_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ULI__Timestamp_encoder(const ULI__Timestamp& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ULI_Timestamp' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ULI__Timestamp_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ULI__Timestamp_decoder(OCTETSTRING& input_stream, ULI__Timestamp& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ULI_Timestamp' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ULI__Timestamp_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void LHN__ID__NSAPI_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(LHN__ID__NSAPI_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER LHN__ID__NSAPI_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(LHN__ID__NSAPI_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void LHN__ID__NSAPI_lHN__ID_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER LHN__ID__NSAPI_lHN__ID_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void LHN__ID__NSAPI_encoder(const LHN__ID__NSAPI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LHN_ID_NSAPI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(LHN__ID__NSAPI_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER LHN__ID__NSAPI_decoder(OCTETSTRING& input_stream, LHN__ID__NSAPI& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.LHN_ID_NSAPI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(LHN__ID__NSAPI_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CN__OperatorSelectionEntity_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CN__OperatorSelectionEntity_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CN__OperatorSelectionEntity_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CN__OperatorSelectionEntity_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CN__OperatorSelectionEntity_explicitly__specified_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CN__OperatorSelectionEntity_explicitly__specified_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CN__OperatorSelectionEntity_encoder(const CN__OperatorSelectionEntity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CN_OperatorSelectionEntity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CN__OperatorSelectionEntity_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CN__OperatorSelectionEntity_decoder(OCTETSTRING& input_stream, CN__OperatorSelectionEntity& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CN_OperatorSelectionEntity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CN__OperatorSelectionEntity_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UE__UsageType_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UE__UsageType_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UE__UsageType_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UE__UsageType_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UE__UsageType_encoder(const UE__UsageType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UE_UsageType' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UE__UsageType_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UE__UsageType_decoder(OCTETSTRING& input_stream, UE__UsageType& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UE_UsageType' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UE__UsageType_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ExtendedCommonFlagsII_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ExtendedCommonFlagsII_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ExtendedCommonFlagsII_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ExtendedCommonFlagsII_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ExtendedCommonFlagsII_explicitly__specified_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ExtendedCommonFlagsII_explicitly__specified_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ExtendedCommonFlagsII_encoder(const ExtendedCommonFlagsII& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ExtendedCommonFlagsII' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ExtendedCommonFlagsII_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ExtendedCommonFlagsII_decoder(OCTETSTRING& input_stream, ExtendedCommonFlagsII& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ExtendedCommonFlagsII' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ExtendedCommonFlagsII_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void NodeIdentifier_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(NodeIdentifier_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER NodeIdentifier_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(NodeIdentifier_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void NodeIdentifier_nodeIdentifier_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER NodeIdentifier_nodeIdentifier_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void NodeIdentifier_encoder(const NodeIdentifier& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.NodeIdentifier' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(NodeIdentifier_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER NodeIdentifier_decoder(OCTETSTRING& input_stream, NodeIdentifier& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.NodeIdentifier' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(NodeIdentifier_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EchoRequest_encoder(const EchoRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EchoRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EchoRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EchoRequest_decoder(OCTETSTRING& input_stream, EchoRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EchoRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EchoRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void EchoResponse_encoder(const EchoResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EchoResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(EchoResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER EchoResponse_decoder(OCTETSTRING& input_stream, EchoResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.EchoResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(EchoResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const VersionNotSupported& other_value) { other_value.must_bound("Comparison of an unbound value of type @GTPC_Types.VersionNotSupported."); return TRUE; } void VersionNotSupported_encoder(const VersionNotSupported& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.VersionNotSupported' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(VersionNotSupported_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER VersionNotSupported_decoder(OCTETSTRING& input_stream, VersionNotSupported& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.VersionNotSupported' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(VersionNotSupported_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SupportedExtensionHeadersNotification_encoder(const SupportedExtensionHeadersNotification& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SupportedExtensionHeadersNotification' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SupportedExtensionHeadersNotification_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SupportedExtensionHeadersNotification_decoder(OCTETSTRING& input_stream, SupportedExtensionHeadersNotification& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SupportedExtensionHeadersNotification' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SupportedExtensionHeadersNotification_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CreatePDPContextRequest_encoder(const CreatePDPContextRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CreatePDPContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CreatePDPContextRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CreatePDPContextRequest_decoder(OCTETSTRING& input_stream, CreatePDPContextRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CreatePDPContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CreatePDPContextRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CreatePDPContextResponse_encoder(const CreatePDPContextResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CreatePDPContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CreatePDPContextResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CreatePDPContextResponse_decoder(OCTETSTRING& input_stream, CreatePDPContextResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CreatePDPContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CreatePDPContextResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UpdatePDPContextRequestSGSN_encoder(const UpdatePDPContextRequestSGSN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextRequestSGSN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UpdatePDPContextRequestSGSN_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UpdatePDPContextRequestSGSN_decoder(OCTETSTRING& input_stream, UpdatePDPContextRequestSGSN& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextRequestSGSN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UpdatePDPContextRequestSGSN_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UpdatePDPContextRequestGGSN_encoder(const UpdatePDPContextRequestGGSN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextRequestGGSN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UpdatePDPContextRequestGGSN_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UpdatePDPContextRequestGGSN_decoder(OCTETSTRING& input_stream, UpdatePDPContextRequestGGSN& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextRequestGGSN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UpdatePDPContextRequestGGSN_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UpdatePDPContextRequestCGW_encoder(const UpdatePDPContextRequestCGW& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextRequestCGW' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UpdatePDPContextRequestCGW_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UpdatePDPContextRequestCGW_decoder(OCTETSTRING& input_stream, UpdatePDPContextRequestCGW& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextRequestCGW' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UpdatePDPContextRequestCGW_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UpdatePDPContextRequest_encoder(const UpdatePDPContextRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UpdatePDPContextRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UpdatePDPContextRequest_decoder(OCTETSTRING& input_stream, UpdatePDPContextRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UpdatePDPContextRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UpdatePDPContextResponseSGSN_encoder(const UpdatePDPContextResponseSGSN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextResponseSGSN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UpdatePDPContextResponseSGSN_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UpdatePDPContextResponseSGSN_decoder(OCTETSTRING& input_stream, UpdatePDPContextResponseSGSN& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextResponseSGSN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UpdatePDPContextResponseSGSN_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UpdatePDPContextResponseGGSN_encoder(const UpdatePDPContextResponseGGSN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextResponseGGSN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UpdatePDPContextResponseGGSN_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UpdatePDPContextResponseGGSN_decoder(OCTETSTRING& input_stream, UpdatePDPContextResponseGGSN& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextResponseGGSN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UpdatePDPContextResponseGGSN_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UpdatePDPContextResponseCGW_encoder(const UpdatePDPContextResponseCGW& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextResponseCGW' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UpdatePDPContextResponseCGW_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UpdatePDPContextResponseCGW_decoder(OCTETSTRING& input_stream, UpdatePDPContextResponseCGW& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextResponseCGW' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UpdatePDPContextResponseCGW_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UpdatePDPContextResponse_encoder(const UpdatePDPContextResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UpdatePDPContextResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UpdatePDPContextResponse_decoder(OCTETSTRING& input_stream, UpdatePDPContextResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdatePDPContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UpdatePDPContextResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void DeletePDPContextRequest_encoder(const DeletePDPContextRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.DeletePDPContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(DeletePDPContextRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER DeletePDPContextRequest_decoder(OCTETSTRING& input_stream, DeletePDPContextRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.DeletePDPContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(DeletePDPContextRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void DeletePDPContextResponse_encoder(const DeletePDPContextResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.DeletePDPContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(DeletePDPContextResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER DeletePDPContextResponse_decoder(OCTETSTRING& input_stream, DeletePDPContextResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.DeletePDPContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(DeletePDPContextResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__NotificationRequest_encoder(const PDU__NotificationRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_NotificationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__NotificationRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__NotificationRequest_decoder(OCTETSTRING& input_stream, PDU__NotificationRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_NotificationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__NotificationRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__NotificationResponse_encoder(const PDU__NotificationResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_NotificationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__NotificationResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__NotificationResponse_decoder(OCTETSTRING& input_stream, PDU__NotificationResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_NotificationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__NotificationResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__NotificationRejectRequest_encoder(const PDU__NotificationRejectRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_NotificationRejectRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__NotificationRejectRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__NotificationRejectRequest_decoder(OCTETSTRING& input_stream, PDU__NotificationRejectRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_NotificationRejectRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__NotificationRejectRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__NotificationRejectResponse_encoder(const PDU__NotificationRejectResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_NotificationRejectResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__NotificationRejectResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__NotificationRejectResponse_decoder(OCTETSTRING& input_stream, PDU__NotificationRejectResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_NotificationRejectResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__NotificationRejectResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void InitiatePDPContextActivationRequest_encoder(const InitiatePDPContextActivationRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.InitiatePDPContextActivationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(InitiatePDPContextActivationRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER InitiatePDPContextActivationRequest_decoder(OCTETSTRING& input_stream, InitiatePDPContextActivationRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.InitiatePDPContextActivationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(InitiatePDPContextActivationRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void InitiatePDPContextActivationResponse_encoder(const InitiatePDPContextActivationResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.InitiatePDPContextActivationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(InitiatePDPContextActivationResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER InitiatePDPContextActivationResponse_decoder(OCTETSTRING& input_stream, InitiatePDPContextActivationResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.InitiatePDPContextActivationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(InitiatePDPContextActivationResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SendRouteingInformationForGPRSRequest_encoder(const SendRouteingInformationForGPRSRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SendRouteingInformationForGPRSRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SendRouteingInformationForGPRSRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SendRouteingInformationForGPRSRequest_decoder(OCTETSTRING& input_stream, SendRouteingInformationForGPRSRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SendRouteingInformationForGPRSRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SendRouteingInformationForGPRSRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SendRouteingInformationForGPRSResponse_encoder(const SendRouteingInformationForGPRSResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SendRouteingInformationForGPRSResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SendRouteingInformationForGPRSResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SendRouteingInformationForGPRSResponse_decoder(OCTETSTRING& input_stream, SendRouteingInformationForGPRSResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SendRouteingInformationForGPRSResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SendRouteingInformationForGPRSResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void FailureReportRequest_encoder(const FailureReportRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.FailureReportRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(FailureReportRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER FailureReportRequest_decoder(OCTETSTRING& input_stream, FailureReportRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.FailureReportRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(FailureReportRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void FailureReportResponse_encoder(const FailureReportResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.FailureReportResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(FailureReportResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER FailureReportResponse_decoder(OCTETSTRING& input_stream, FailureReportResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.FailureReportResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(FailureReportResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void NoteMS__GPRSPresentRequest_encoder(const NoteMS__GPRSPresentRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.NoteMS_GPRSPresentRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(NoteMS__GPRSPresentRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER NoteMS__GPRSPresentRequest_decoder(OCTETSTRING& input_stream, NoteMS__GPRSPresentRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.NoteMS_GPRSPresentRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(NoteMS__GPRSPresentRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void NoteMS__GPRSPresentResponse_encoder(const NoteMS__GPRSPresentResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.NoteMS_GPRSPresentResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(NoteMS__GPRSPresentResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER NoteMS__GPRSPresentResponse_decoder(OCTETSTRING& input_stream, NoteMS__GPRSPresentResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.NoteMS_GPRSPresentResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(NoteMS__GPRSPresentResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void IdentificationRequest_encoder(const IdentificationRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.IdentificationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(IdentificationRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER IdentificationRequest_decoder(OCTETSTRING& input_stream, IdentificationRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.IdentificationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(IdentificationRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void IdentificationResponse_encoder(const IdentificationResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.IdentificationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(IdentificationResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER IdentificationResponse_decoder(OCTETSTRING& input_stream, IdentificationResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.IdentificationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(IdentificationResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SGSN__ContextRequest_encoder(const SGSN__ContextRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SGSN_ContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SGSN__ContextRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SGSN__ContextRequest_decoder(OCTETSTRING& input_stream, SGSN__ContextRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SGSN_ContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SGSN__ContextRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SGSN__ContextResponse_encoder(const SGSN__ContextResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SGSN_ContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SGSN__ContextResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SGSN__ContextResponse_decoder(OCTETSTRING& input_stream, SGSN__ContextResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SGSN_ContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SGSN__ContextResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void SGSN__ContextAcknowledge_encoder(const SGSN__ContextAcknowledge& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SGSN_ContextAcknowledge' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(SGSN__ContextAcknowledge_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER SGSN__ContextAcknowledge_decoder(OCTETSTRING& input_stream, SGSN__ContextAcknowledge& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.SGSN_ContextAcknowledge' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(SGSN__ContextAcknowledge_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ForwardRelocationRequest_encoder(const ForwardRelocationRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardRelocationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ForwardRelocationRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ForwardRelocationRequest_decoder(OCTETSTRING& input_stream, ForwardRelocationRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardRelocationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ForwardRelocationRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ForwardRelocationResponse_encoder(const ForwardRelocationResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardRelocationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ForwardRelocationResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ForwardRelocationResponse_decoder(OCTETSTRING& input_stream, ForwardRelocationResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardRelocationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ForwardRelocationResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ForwardRelocationComplete_encoder(const ForwardRelocationComplete& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardRelocationComplete' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ForwardRelocationComplete_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ForwardRelocationComplete_decoder(OCTETSTRING& input_stream, ForwardRelocationComplete& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardRelocationComplete' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ForwardRelocationComplete_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RelocationCancelRequest_encoder(const RelocationCancelRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RelocationCancelRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RelocationCancelRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RelocationCancelRequest_decoder(OCTETSTRING& input_stream, RelocationCancelRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RelocationCancelRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RelocationCancelRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RelocationCancelResponse_encoder(const RelocationCancelResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RelocationCancelResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RelocationCancelResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RelocationCancelResponse_decoder(OCTETSTRING& input_stream, RelocationCancelResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RelocationCancelResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RelocationCancelResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ForwardRelocationCompleteAcknowledge_encoder(const ForwardRelocationCompleteAcknowledge& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardRelocationCompleteAcknowledge' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ForwardRelocationCompleteAcknowledge_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ForwardRelocationCompleteAcknowledge_decoder(OCTETSTRING& input_stream, ForwardRelocationCompleteAcknowledge& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardRelocationCompleteAcknowledge' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ForwardRelocationCompleteAcknowledge_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ForwardSRNSContextAcknowledge_encoder(const ForwardSRNSContextAcknowledge& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardSRNSContextAcknowledge' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ForwardSRNSContextAcknowledge_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ForwardSRNSContextAcknowledge_decoder(OCTETSTRING& input_stream, ForwardSRNSContextAcknowledge& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardSRNSContextAcknowledge' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ForwardSRNSContextAcknowledge_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void ForwardSRNSContext_encoder(const ForwardSRNSContext& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardSRNSContext' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(ForwardSRNSContext_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER ForwardSRNSContext_decoder(OCTETSTRING& input_stream, ForwardSRNSContext& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.ForwardSRNSContext' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(ForwardSRNSContext_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void RANInformationRelay_encoder(const RANInformationRelay& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RANInformationRelay' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(RANInformationRelay_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER RANInformationRelay_decoder(OCTETSTRING& input_stream, RANInformationRelay& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.RANInformationRelay' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(RANInformationRelay_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UERegistrationQueryRequest_encoder(const UERegistrationQueryRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UERegistrationQueryRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UERegistrationQueryRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UERegistrationQueryRequest_decoder(OCTETSTRING& input_stream, UERegistrationQueryRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UERegistrationQueryRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UERegistrationQueryRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UERegistrationQueryResponse_encoder(const UERegistrationQueryResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UERegistrationQueryResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UERegistrationQueryResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UERegistrationQueryResponse_decoder(OCTETSTRING& input_stream, UERegistrationQueryResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UERegistrationQueryResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UERegistrationQueryResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSNotificationRequest_encoder(const MBMSNotificationRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSNotificationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSNotificationRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSNotificationRequest_decoder(OCTETSTRING& input_stream, MBMSNotificationRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSNotificationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSNotificationRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSNotificationResponse_encoder(const MBMSNotificationResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSNotificationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSNotificationResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSNotificationResponse_decoder(OCTETSTRING& input_stream, MBMSNotificationResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSNotificationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSNotificationResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSNotificationRejectRequest_encoder(const MBMSNotificationRejectRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSNotificationRejectRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSNotificationRejectRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSNotificationRejectRequest_decoder(OCTETSTRING& input_stream, MBMSNotificationRejectRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSNotificationRejectRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSNotificationRejectRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSNotificationRejectResponse_encoder(const MBMSNotificationRejectResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSNotificationRejectResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSNotificationRejectResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSNotificationRejectResponse_decoder(OCTETSTRING& input_stream, MBMSNotificationRejectResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSNotificationRejectResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSNotificationRejectResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CreateMBMSContextRequest_encoder(const CreateMBMSContextRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CreateMBMSContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CreateMBMSContextRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CreateMBMSContextRequest_decoder(OCTETSTRING& input_stream, CreateMBMSContextRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CreateMBMSContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CreateMBMSContextRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void CreateMBMSContextResponse_encoder(const CreateMBMSContextResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CreateMBMSContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(CreateMBMSContextResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER CreateMBMSContextResponse_decoder(OCTETSTRING& input_stream, CreateMBMSContextResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.CreateMBMSContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(CreateMBMSContextResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UpdateMBMSContextRequest_encoder(const UpdateMBMSContextRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdateMBMSContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UpdateMBMSContextRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UpdateMBMSContextRequest_decoder(OCTETSTRING& input_stream, UpdateMBMSContextRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdateMBMSContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UpdateMBMSContextRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void UpdateMBMSContextResponse_encoder(const UpdateMBMSContextResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdateMBMSContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(UpdateMBMSContextResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER UpdateMBMSContextResponse_decoder(OCTETSTRING& input_stream, UpdateMBMSContextResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.UpdateMBMSContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(UpdateMBMSContextResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void DeleteMBMSContextRequest_encoder(const DeleteMBMSContextRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.DeleteMBMSContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(DeleteMBMSContextRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER DeleteMBMSContextRequest_decoder(OCTETSTRING& input_stream, DeleteMBMSContextRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.DeleteMBMSContextRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(DeleteMBMSContextRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void DeleteMBMSContextResponse_encoder(const DeleteMBMSContextResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.DeleteMBMSContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(DeleteMBMSContextResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER DeleteMBMSContextResponse_decoder(OCTETSTRING& input_stream, DeleteMBMSContextResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.DeleteMBMSContextResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(DeleteMBMSContextResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSRegistrationRequest__gtpc_encoder(const MBMSRegistrationRequest__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSRegistrationRequest_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSRegistrationRequest__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSRegistrationRequest__gtpc_decoder(OCTETSTRING& input_stream, MBMSRegistrationRequest__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSRegistrationRequest_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSRegistrationRequest__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSRegistrationResponse__gtpc_encoder(const MBMSRegistrationResponse__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSRegistrationResponse_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSRegistrationResponse__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSRegistrationResponse__gtpc_decoder(OCTETSTRING& input_stream, MBMSRegistrationResponse__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSRegistrationResponse_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSRegistrationResponse__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSDeRegistrationRequest_encoder(const MBMSDeRegistrationRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSDeRegistrationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSDeRegistrationRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSDeRegistrationRequest_decoder(OCTETSTRING& input_stream, MBMSDeRegistrationRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSDeRegistrationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSDeRegistrationRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSDeRegistrationResponse_encoder(const MBMSDeRegistrationResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSDeRegistrationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSDeRegistrationResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSDeRegistrationResponse_decoder(OCTETSTRING& input_stream, MBMSDeRegistrationResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSDeRegistrationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSDeRegistrationResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSSessionStartRequest_encoder(const MBMSSessionStartRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionStartRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSSessionStartRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSSessionStartRequest_decoder(OCTETSTRING& input_stream, MBMSSessionStartRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionStartRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSSessionStartRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSSessionStartResponse__gtpc_encoder(const MBMSSessionStartResponse__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionStartResponse_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSSessionStartResponse__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSSessionStartResponse__gtpc_decoder(OCTETSTRING& input_stream, MBMSSessionStartResponse__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionStartResponse_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSSessionStartResponse__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSSessionStopRequest_encoder(const MBMSSessionStopRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionStopRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSSessionStopRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSSessionStopRequest_decoder(OCTETSTRING& input_stream, MBMSSessionStopRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionStopRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSSessionStopRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSSessionStopResponse__gtpc_encoder(const MBMSSessionStopResponse__gtpc& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionStopResponse_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSSessionStopResponse__gtpc_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSSessionStopResponse__gtpc_decoder(OCTETSTRING& input_stream, MBMSSessionStopResponse__gtpc& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionStopResponse_gtpc' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSSessionStopResponse__gtpc_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSSessionUpdateRequest_encoder(const MBMSSessionUpdateRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionUpdateRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSSessionUpdateRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSSessionUpdateRequest_decoder(OCTETSTRING& input_stream, MBMSSessionUpdateRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionUpdateRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSSessionUpdateRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MBMSSessionUpdateResponse_encoder(const MBMSSessionUpdateResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionUpdateResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MBMSSessionUpdateResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MBMSSessionUpdateResponse_decoder(OCTETSTRING& input_stream, MBMSSessionUpdateResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MBMSSessionUpdateResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MBMSSessionUpdateResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MS__InfoChangeNotificationRequest_encoder(const MS__InfoChangeNotificationRequest& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MS_InfoChangeNotificationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MS__InfoChangeNotificationRequest_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MS__InfoChangeNotificationRequest_decoder(OCTETSTRING& input_stream, MS__InfoChangeNotificationRequest& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MS_InfoChangeNotificationRequest' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MS__InfoChangeNotificationRequest_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void MS__InfoChangeNotificationResponse_encoder(const MS__InfoChangeNotificationResponse& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MS_InfoChangeNotificationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(MS__InfoChangeNotificationResponse_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER MS__InfoChangeNotificationResponse_decoder(OCTETSTRING& input_stream, MS__InfoChangeNotificationResponse& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.MS_InfoChangeNotificationResponse' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(MS__InfoChangeNotificationResponse_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTPC__PDUs_encoder(const GTPC__PDUs& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_PDUs' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GTPC__PDUs_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTPC__PDUs_decoder(OCTETSTRING& input_stream, GTPC__PDUs& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_PDUs' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GTPC__PDUs_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__GTPC_lengthf_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__GTPC_lengthf_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__GTPC_lengthf_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__GTPC_lengthf_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__GTPC_gtpc__pdu_encoder(const GTPC__PDUs& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_PDUs' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__GTPC_gtpc__pdu_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__GTPC_gtpc__pdu_decoder(OCTETSTRING& input_stream, GTPC__PDUs& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_PDUs' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__GTPC_gtpc__pdu_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } boolean operator==(null_type, const GTPC__ExtensionHeader__List& other_value) { if (other_value.val_ptr == NULL) TTCN_error("The right operand of comparison is an unbound value of type @GTPC_Types.GTPC_ExtensionHeader_List."); return other_value.val_ptr->n_elements == 0; } void GTPC__ExtensionHeader_lengthfield_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GTPC__ExtensionHeader_lengthfield_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTPC__ExtensionHeader_lengthfield_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `integer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GTPC__ExtensionHeader_lengthfield_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTPC__ExtensionHeader_content_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTPC__ExtensionHeader_content_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(OCTETSTRING_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTPC__ExtensionHeader_nextExtHeader_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GTPC__ExtensionHeader_nextExtHeader_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTPC__ExtensionHeader_nextExtHeader_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `octetstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GTPC__ExtensionHeader_nextExtHeader_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTPC__ExtensionHeader_encoder(const GTPC__ExtensionHeader& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_ExtensionHeader' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GTPC__ExtensionHeader_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTPC__ExtensionHeader_decoder(OCTETSTRING& input_stream, GTPC__ExtensionHeader& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_ExtensionHeader' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GTPC__ExtensionHeader_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTPC__ExtensionHeader__List_encoder(const GTPC__ExtensionHeader__List& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_ExtensionHeader_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GTPC__ExtensionHeader__List_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTPC__ExtensionHeader__List_decoder(OCTETSTRING& input_stream, GTPC__ExtensionHeader__List& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_ExtensionHeader_List' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GTPC__ExtensionHeader__List_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void GTPC__Header__optional__part_encoder(const GTPC__Header__optional__part& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_Header_optional_part' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(GTPC__Header__optional__part_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER GTPC__Header__optional__part_decoder(OCTETSTRING& input_stream, GTPC__Header__optional__part& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_Header_optional_part' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(GTPC__Header__optional__part_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__GTPC_opt__part_encoder(const GTPC__Header__optional__part& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_Header_optional_part' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__GTPC_opt__part_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__GTPC_opt__part_decoder(OCTETSTRING& input_stream, GTPC__Header__optional__part& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.GTPC_Header_optional_part' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__GTPC_opt__part_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } void PDU__GTPC_encoder(const PDU__GTPC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf; input_value.encode(PDU__GTPC_descr_, ttcn_buf, coding_type, extra_options); ttcn_buf.get_string(output_stream); } INTEGER PDU__GTPC_decoder(OCTETSTRING& input_stream, PDU__GTPC& output_value, const UNIVERSAL_CHARSTRING& coding_name) { TTCN_EncDec::coding_t coding_type; unsigned int extra_options = 0; TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE); if (coding_type != TTCN_EncDec::CT_RAW) { TTCN_Logger::begin_event_log2str(); coding_name.log(); TTCN_error("Type `@GTPC_Types.PDU_GTPC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str()); } TTCN_Buffer ttcn_buf(input_stream); output_value.decode(PDU__GTPC_descr_, ttcn_buf, coding_type, extra_options); switch (TTCN_EncDec::get_last_error_type()) { case TTCN_EncDec::ET_NONE: ttcn_buf.cut(); ttcn_buf.get_string(input_stream); return 0; case TTCN_EncDec::ET_INCOMPL_MSG: case TTCN_EncDec::ET_LEN_ERR: return 2; default: return 1; } } /* Bodies of static functions */ void pre_init_module() { TTCN_Location current_location("GTPC_Types.ttcn", 0, TTCN_Location::LOCATION_UNKNOWN, "GTPC_Types"); General__Types::module_object.pre_init_module(); module_object.add_function("enc_PDU_GTPC", (genericfunc_t)&enc__PDU__GTPC, NULL); module_object.add_function("dec_PDU_GTPC", (genericfunc_t)&dec__PDU__GTPC, NULL); current_location.update_lineno(2816); /* GTPC_Types.ttcn, line 2816 */ const_echoRequest = os_13; current_location.update_lineno(2817); /* GTPC_Types.ttcn, line 2817 */ const_echoResponse = os_2; current_location.update_lineno(2818); /* GTPC_Types.ttcn, line 2818 */ const_versionNotSupported = os_3; current_location.update_lineno(2825); /* GTPC_Types.ttcn, line 2825 */ const_createPDPContextRequest = os_5; current_location.update_lineno(2826); /* GTPC_Types.ttcn, line 2826 */ const_createPDPContextResponse = os_6; current_location.update_lineno(2827); /* GTPC_Types.ttcn, line 2827 */ const_updatePDPContextRequest = os_81; current_location.update_lineno(2828); /* GTPC_Types.ttcn, line 2828 */ const_updatePDPContextResponse = os_48; current_location.update_lineno(2829); /* GTPC_Types.ttcn, line 2829 */ const_deletePDPContextRequest = os_7; current_location.update_lineno(2830); /* GTPC_Types.ttcn, line 2830 */ const_deletePDPContextResponse = os_83; current_location.update_lineno(2831); /* GTPC_Types.ttcn, line 2831 */ const_initiatePDPContextActivationRequest = os_61; current_location.update_lineno(2832); /* GTPC_Types.ttcn, line 2832 */ const_initiatePDPContextActivationResponse = os_62; current_location.update_lineno(2839); /* GTPC_Types.ttcn, line 2839 */ const_pduNotificationRequest = os_9; current_location.update_lineno(2840); /* GTPC_Types.ttcn, line 2840 */ const_pduNotificationResponse = os_10; current_location.update_lineno(2841); /* GTPC_Types.ttcn, line 2841 */ const_pduNotificationRejectRequest = os_51; current_location.update_lineno(2842); /* GTPC_Types.ttcn, line 2842 */ const_pduNotificationRejectResponse = os_131; current_location.update_lineno(2844); /* GTPC_Types.ttcn, line 2844 */ const_supportedExtHeadersNotification = os_132; current_location.update_lineno(2845); /* GTPC_Types.ttcn, line 2845 */ const_sendRoutingInfoForGPRSRequest = os_133; current_location.update_lineno(2846); /* GTPC_Types.ttcn, line 2846 */ const_sendRoutingInfoForGPRSResponse = os_11; current_location.update_lineno(2847); /* GTPC_Types.ttcn, line 2847 */ const_failureReportRequest = os_134; current_location.update_lineno(2848); /* GTPC_Types.ttcn, line 2848 */ const_failureReportResponse = os_135; current_location.update_lineno(2849); /* GTPC_Types.ttcn, line 2849 */ const_noteMS__GPRSPresentRequest = os_136; current_location.update_lineno(2850); /* GTPC_Types.ttcn, line 2850 */ const_noteMS__GPRSPresentResponse = os_137; current_location.update_lineno(2855); /* GTPC_Types.ttcn, line 2855 */ const_identificationRequest = os_138; current_location.update_lineno(2856); /* GTPC_Types.ttcn, line 2856 */ const_identificationResponse = os_139; current_location.update_lineno(2857); /* GTPC_Types.ttcn, line 2857 */ const_sgsnContextRequest = os_140; current_location.update_lineno(2858); /* GTPC_Types.ttcn, line 2858 */ const_sgsnContextResponse = os_141; current_location.update_lineno(2859); /* GTPC_Types.ttcn, line 2859 */ const_sgsnContextAcknowledge = os_142; current_location.update_lineno(2860); /* GTPC_Types.ttcn, line 2860 */ const_forwardRelocationRequest = os_143; current_location.update_lineno(2861); /* GTPC_Types.ttcn, line 2861 */ const_forwardRelocationResponse = os_144; current_location.update_lineno(2862); /* GTPC_Types.ttcn, line 2862 */ const_forwardRelocationComplete = os_145; current_location.update_lineno(2863); /* GTPC_Types.ttcn, line 2863 */ const_relocationCancelRequest = os_146; current_location.update_lineno(2864); /* GTPC_Types.ttcn, line 2864 */ const_relocationCancelResponse = os_147; current_location.update_lineno(2865); /* GTPC_Types.ttcn, line 2865 */ const_forwardSRNSContext = os_148; current_location.update_lineno(2866); /* GTPC_Types.ttcn, line 2866 */ const_forwardRelocationCompleteAcknowledge = os_149; current_location.update_lineno(2867); /* GTPC_Types.ttcn, line 2867 */ const_forwardSRNSContextAcknowledge = os_150; current_location.update_lineno(2868); /* GTPC_Types.ttcn, line 2868 */ const_ueRegistrationQueryRequest = os_151; current_location.update_lineno(2869); /* GTPC_Types.ttcn, line 2869 */ const_ueRegistrationQueryResponse = os_170; current_location.update_lineno(2874); /* GTPC_Types.ttcn, line 2874 */ const_rANInformationRelay = os_153; current_location.update_lineno(2879); /* GTPC_Types.ttcn, line 2879 */ const_mBMSNotificationRequest = os_154; current_location.update_lineno(2880); /* GTPC_Types.ttcn, line 2880 */ const_mBMSNotificationResponse = os_155; current_location.update_lineno(2881); /* GTPC_Types.ttcn, line 2881 */ const_mBMSNotificationRejectRequest = os_156; current_location.update_lineno(2882); /* GTPC_Types.ttcn, line 2882 */ const_mBMSNotificationRejectResponse = os_157; current_location.update_lineno(2883); /* GTPC_Types.ttcn, line 2883 */ const_createMBMSContextRequest = os_158; current_location.update_lineno(2884); /* GTPC_Types.ttcn, line 2884 */ const_createMBMSContextResponse = os_159; current_location.update_lineno(2885); /* GTPC_Types.ttcn, line 2885 */ const_updateMBMSContextRequest = os_160; current_location.update_lineno(2886); /* GTPC_Types.ttcn, line 2886 */ const_updateMBMSContextResponse = os_161; current_location.update_lineno(2887); /* GTPC_Types.ttcn, line 2887 */ const_deleteMBMSContextRequest = os_162; current_location.update_lineno(2888); /* GTPC_Types.ttcn, line 2888 */ const_deleteMBMSContextResponse = os_163; current_location.update_lineno(2893); /* GTPC_Types.ttcn, line 2893 */ const_mBMSRegistrationRequest = os_110; current_location.update_lineno(2894); /* GTPC_Types.ttcn, line 2894 */ const_mBMSRegistrationResponse = os_109; current_location.update_lineno(2895); /* GTPC_Types.ttcn, line 2895 */ const_mBMSDeRegistrationRequest = os_111; current_location.update_lineno(2896); /* GTPC_Types.ttcn, line 2896 */ const_mBMSDeRegistrationResponse = os_112; current_location.update_lineno(2898); /* GTPC_Types.ttcn, line 2898 */ const_mBMSSessionStartRequest = os_113; current_location.update_lineno(2899); /* GTPC_Types.ttcn, line 2899 */ const_mBMSSessionStartResponse = os_164; current_location.update_lineno(2900); /* GTPC_Types.ttcn, line 2900 */ const_mBMSSessionStopRequest = os_165; current_location.update_lineno(2901); /* GTPC_Types.ttcn, line 2901 */ const_mBMSSessionStopResponse = os_166; current_location.update_lineno(2903); /* GTPC_Types.ttcn, line 2903 */ const_mBMSSessionUpdateRequest = os_167; current_location.update_lineno(2904); /* GTPC_Types.ttcn, line 2904 */ const_mBMSSessionUpdateResponse = os_168; current_location.update_lineno(2909); /* GTPC_Types.ttcn, line 2909 */ const_mS__InfoChangeNotificationRequest = os_15; current_location.update_lineno(2910); /* GTPC_Types.ttcn, line 2910 */ const_mS__InfoChangeNotificationResponse = os_65; current_location.update_lineno(2922); /* GTPC_Types.ttcn, line 2922 */ const_g__PDU = os_0; } void post_init_module() { TTCN_Location current_location("GTPC_Types.ttcn", 0, TTCN_Location::LOCATION_UNKNOWN, "GTPC_Types"); General__Types::module_object.post_init_module(); current_location.update_lineno(27); /* GTPC_Types.ttcn, line 27 */ const_dec__PDU__GTPC_pl__SystemUnderTest_defval = SystemUnderTest::SGSN; } } /* end of namespace */