// This C++ source file was generated by the TTCN-3 compiler
// of the TTCN-3 Test Executor version 11.1.0
// The generation of user and time information were disabled by the -D flag.

// Copyright (c) 2000-2025 Ericsson Telecom AB

// Do not edit this file unless you know what you are doing.

/* Including header files */

#include "DIAMETER_Types.hh"

namespace DIAMETER__Types {

/* Member functions of C++ classes */

Undefined__AVP::Undefined__AVP()
{
}

Undefined__AVP::Undefined__AVP(const OCTETSTRING& par_avp__code,
    const BITSTRING& par_VMPxxxxx,
    const INTEGER& par_avp__length,
    const OPTIONAL< OCTETSTRING >& par_vendor__id,
    const OCTETSTRING& par_avp__data)
  :   field_avp__code(par_avp__code),
  field_VMPxxxxx(par_VMPxxxxx),
  field_avp__length(par_avp__length),
  field_vendor__id(par_vendor__id),
  field_avp__data(par_avp__data)
{
}

Undefined__AVP::Undefined__AVP(const Undefined__AVP& other_value)
{
if(!other_value.is_bound()) TTCN_error("Copying an unbound value of type @DIAMETER_Types.Undefined_AVP.");
if (other_value.avp__code().is_bound()) field_avp__code = other_value.avp__code();
else field_avp__code.clean_up();
if (other_value.VMPxxxxx().is_bound()) field_VMPxxxxx = other_value.VMPxxxxx();
else field_VMPxxxxx.clean_up();
if (other_value.avp__length().is_bound()) field_avp__length = other_value.avp__length();
else field_avp__length.clean_up();
if (other_value.vendor__id().is_bound()) field_vendor__id = other_value.vendor__id();
else field_vendor__id.clean_up();
if (other_value.avp__data().is_bound()) field_avp__data = other_value.avp__data();
else field_avp__data.clean_up();
}

void Undefined__AVP::clean_up()
{
field_avp__code.clean_up();
field_VMPxxxxx.clean_up();
field_avp__length.clean_up();
field_vendor__id.clean_up();
field_avp__data.clean_up();
}

const TTCN_Typedescriptor_t* Undefined__AVP::get_descriptor() const { return &Undefined__AVP_descr_; }
Undefined__AVP& Undefined__AVP::operator=(const Undefined__AVP& other_value)
{
if (this != &other_value) {
  if(!other_value.is_bound()) TTCN_error("Assignment of an unbound value of type @DIAMETER_Types.Undefined_AVP.");
  if (other_value.avp__code().is_bound()) field_avp__code = other_value.avp__code();
  else field_avp__code.clean_up();
  if (other_value.VMPxxxxx().is_bound()) field_VMPxxxxx = other_value.VMPxxxxx();
  else field_VMPxxxxx.clean_up();
  if (other_value.avp__length().is_bound()) field_avp__length = other_value.avp__length();
  else field_avp__length.clean_up();
  if (other_value.vendor__id().is_bound()) field_vendor__id = other_value.vendor__id();
  else field_vendor__id.clean_up();
  if (other_value.avp__data().is_bound()) field_avp__data = other_value.avp__data();
  else field_avp__data.clean_up();
}
return *this;
}

boolean Undefined__AVP::operator==(const Undefined__AVP& other_value) const
{
return field_avp__code==other_value.field_avp__code
  && field_VMPxxxxx==other_value.field_VMPxxxxx
  && field_avp__length==other_value.field_avp__length
  && field_vendor__id==other_value.field_vendor__id
  && field_avp__data==other_value.field_avp__data;
}

boolean Undefined__AVP::is_bound() const
{
return (field_avp__code.is_bound())
  || (field_VMPxxxxx.is_bound())
  || (field_avp__length.is_bound())
  || (OPTIONAL_OMIT == field_vendor__id.get_selection() || field_vendor__id.is_bound())
  || (field_avp__data.is_bound());
}
boolean Undefined__AVP::is_value() const
{
return field_avp__code.is_value()
  && field_VMPxxxxx.is_value()
  && field_avp__length.is_value()
  && (OPTIONAL_OMIT == field_vendor__id.get_selection() || field_vendor__id.is_value())
  && field_avp__data.is_value();
}
int Undefined__AVP::size_of() const
{
  int ret_val = 4;
  if (field_vendor__id.ispresent()) ret_val++;
  return ret_val;
}

void Undefined__AVP::log() const
{
if (!is_bound()) {
TTCN_Logger::log_event_unbound();
return;
}
TTCN_Logger::log_event_str("{ avp_code := ");
field_avp__code.log();
TTCN_Logger::log_event_str(", VMPxxxxx := ");
field_VMPxxxxx.log();
TTCN_Logger::log_event_str(", avp_length := ");
field_avp__length.log();
TTCN_Logger::log_event_str(", vendor_id := ");
field_vendor__id.log();
TTCN_Logger::log_event_str(", avp_data := ");
field_avp__data.log();
TTCN_Logger::log_event_str(" }");
}

void Undefined__AVP::set_implicit_omit()
{
if (avp__code().is_bound()) avp__code().set_implicit_omit();
if (VMPxxxxx().is_bound()) VMPxxxxx().set_implicit_omit();
if (avp__length().is_bound()) avp__length().set_implicit_omit();
if (!vendor__id().is_bound()) vendor__id() = OMIT_VALUE;
else vendor__id().set_implicit_omit();
if (avp__data().is_bound()) avp__data().set_implicit_omit();
}

void Undefined__AVP::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 (5<param.get_size()) {
      param.error("record value of type @DIAMETER_Types.Undefined_AVP has 5 fields but list value has %d fields", (int)param.get_size());
    }
    if (param.get_size()>0 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) avp__code().set_param(*param.get_elem(0));
    if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) VMPxxxxx().set_param(*param.get_elem(1));
    if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) avp__length().set_param(*param.get_elem(2));
    if (param.get_size()>3 && param.get_elem(3)->get_type()!=Module_Param::MP_NotUsed) vendor__id().set_param(*param.get_elem(3));
    if (param.get_size()>4 && param.get_elem(4)->get_type()!=Module_Param::MP_NotUsed) avp__data().set_param(*param.get_elem(4));
    break;
  case Module_Param::MP_Assignment_List: {
    Vector<bool> value_used(param.get_size());
    value_used.resize(param.get_size(), FALSE);
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "avp_code")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          avp__code().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "VMPxxxxx")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          VMPxxxxx().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "avp_length")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          avp__length().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "vendor_id")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          vendor__id().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "avp_data")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          avp__data().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) if (!value_used[val_idx]) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      curr_param->error("Non existent field name in type @DIAMETER_Types.Undefined_AVP: %s", curr_param->get_id()->get_name());
      break;
    }
  } break;
  default:
    param.type_error("record value", "@DIAMETER_Types.Undefined_AVP");
  }
}

void Undefined__AVP::encode_text(Text_Buf& text_buf) const
{
field_avp__code.encode_text(text_buf);
field_VMPxxxxx.encode_text(text_buf);
field_avp__length.encode_text(text_buf);
field_vendor__id.encode_text(text_buf);
field_avp__data.encode_text(text_buf);
}

void Undefined__AVP::decode_text(Text_Buf& text_buf)
{
field_avp__code.decode_text(text_buf);
field_VMPxxxxx.decode_text(text_buf);
field_avp__length.decode_text(text_buf);
field_vendor__id.decode_text(text_buf);
field_avp__data.decode_text(text_buf);
}

void Undefined__AVP::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;}
  case TTCN_EncDec::CT_PER: {
    TTCN_EncDec_ErrorContext ec("While PER-encoding type '%s': ", p_td.name);
    if (!p_td.per) TTCN_EncDec_ErrorContext::error_internal(
      "No PER descriptor available for type '%s'.", p_td.name);
    int opt = va_arg(pvar, int);
    PER_encode(p_td, p_buf, opt);
    break; }
  default:
    TTCN_error("Unknown coding method requested to encode type '%s'", p_td.name);
  }
  va_end(pvar);
}

void Undefined__AVP::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;}
  case TTCN_EncDec::CT_PER: {
    TTCN_EncDec_ErrorContext ec("While PER-decoding type '%s': ", p_td.name);
    if(!p_td.per)  TTCN_EncDec_ErrorContext::error_internal(
      "No PER descriptor available for type '%s'.", p_td.name);
    int opt = va_arg(pvar, int);
    try {
      PER_decode(p_td, p_buf, opt);
      p_buf.PER_octet_align(FALSE);
    }
    catch (PER_Buffer_Exception) { }
    break; }
  default:
    TTCN_error("Unknown coding method requested to decode type '%s'", p_td.name);
  }
  va_end(pvar);
}

int Undefined__AVP::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_field2 = 0;
  RAW_Force_Omit field_0_force_omit(0, force_omit, OCTET4_descr_.raw->forceomit);
  decoded_field_length = field_avp__code.RAW_decode(OCTET4_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());
  value_of_length_field2 -= decoded_field_length;
  RAW_Force_Omit field_1_force_omit(1, force_omit, BIT8_descr_.raw->forceomit);
  decoded_field_length = field_VMPxxxxx.RAW_decode(BIT8_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());
  value_of_length_field2 -= decoded_field_length;
  RAW_Force_Omit field_2_force_omit(2, force_omit, Undefined__AVP_avp__length_descr_.raw->forceomit);
  decoded_field_length = field_avp__length.RAW_decode(Undefined__AVP_avp__length_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());
  INTEGER tmp2 = field_avp__length.convert_to_Integer(Undefined__AVP_avp__length_descr_);
  field_avp__length = tmp2;
  value_of_length_field2 += tmp2.get_long_long_val() * 8;
  value_of_length_field2 -= decoded_field_length;
  if (value_of_length_field2 < 0) return -1;
  if (limit > 0 && value_of_length_field2 > 0 && (field_VMPxxxxx ==  bs_0 || field_VMPxxxxx ==  bs_1 || field_VMPxxxxx ==  bs_2 || field_VMPxxxxx ==  bs_3)){
  if (force_omit != NULL && (*force_omit)(3)) {
    field_vendor__id = OMIT_VALUE;
  }
  else {
  size_t fl_start_pos = p_buf.get_pos_bit();
  RAW_Force_Omit field_3_force_omit(3, force_omit, Undefined__AVP_vendor__id_descr_.raw->forceomit);
  decoded_field_length = field_vendor__id().RAW_decode(Undefined__AVP_vendor__id_descr_, p_buf, min_of_ints(2, limit, value_of_length_field2), local_top_order, TRUE, -1, TRUE, &field_3_force_omit);
  if (decoded_field_length < 1) {
  field_vendor__id = 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_field2 -= decoded_field_length;
  }
  }
  }
  else field_vendor__id=OMIT_VALUE;
  RAW_Force_Omit field_4_force_omit(4, force_omit, OCTETSTRING_descr_.raw->forceomit);
  decoded_field_length = field_avp__data.RAW_decode(OCTETSTRING_descr_, p_buf, min_of_ints(2, limit, value_of_length_field2), 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());
  value_of_length_field2 -= 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 Undefined__AVP::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 = 5;
  myleaf.body.node.nodes = init_nodes_of_enc_tree(5);
  myleaf.body.node.nodes[0] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 0, OCTET4_descr_.raw);
  myleaf.body.node.nodes[1] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 1, BIT8_descr_.raw);
  myleaf.body.node.nodes[2] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 2, Undefined__AVP_avp__length_descr_.raw);
  if (field_vendor__id.ispresent()) {
  myleaf.body.node.nodes[3] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 3, Undefined__AVP_vendor__id_descr_.raw);
  }
  else myleaf.body.node.nodes[3] = NULL;
  myleaf.body.node.nodes[4] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 4, OCTETSTRING_descr_.raw);
  encoded_length += field_avp__code.RAW_encode(OCTET4_descr_, *myleaf.body.node.nodes[0]);
  encoded_length += field_VMPxxxxx.RAW_encode(BIT8_descr_, *myleaf.body.node.nodes[1]);
  encoded_length += 24;
  myleaf.body.node.nodes[2]->calc = CALC_LENGTH;
  myleaf.body.node.nodes[2]->coding_descr = &Undefined__AVP_avp__length_descr_;
  myleaf.body.node.nodes[2]->calcof.lengthto.num_of_fields = 5;
  myleaf.body.node.nodes[2]->calcof.lengthto.unit = 8;
  myleaf.body.node.nodes[2]->calcof.lengthto.offset = 0;
  myleaf.body.node.nodes[2]->calcof.lengthto.fields = init_lengthto_fields_list(5);
  myleaf.body.node.nodes[2]->length = 24;
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[0].level = myleaf.body.node.nodes[0]->curr_pos.level;
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[0].pos = myleaf.body.node.nodes[0]->curr_pos.pos;
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[1].level = myleaf.body.node.nodes[1]->curr_pos.level;
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[1].pos = myleaf.body.node.nodes[1]->curr_pos.pos;
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[2].level = myleaf.body.node.nodes[2]->curr_pos.level;
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[2].pos = myleaf.body.node.nodes[2]->curr_pos.pos;
  if (field_vendor__id.ispresent()) {
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[3].level = myleaf.body.node.nodes[3]->curr_pos.level;
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[3].pos = myleaf.body.node.nodes[3]->curr_pos.pos;
  } else {
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[3].level = 0;
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[3].pos = 0;
  }
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[4].level = myleaf.body.node.nodes[4]->curr_pos.level;
  myleaf.body.node.nodes[2]->calcof.lengthto.fields[4].pos = myleaf.body.node.nodes[4]->curr_pos.pos;
  if (field_vendor__id.ispresent()) {
  encoded_length += field_vendor__id().RAW_encode(Undefined__AVP_vendor__id_descr_, *myleaf.body.node.nodes[3]);
  }
  encoded_length += field_avp__data.RAW_encode(OCTETSTRING_descr_, *myleaf.body.node.nodes[4]);
  if (field_vendor__id.ispresent() && (field_VMPxxxxx !=  bs_0 && field_VMPxxxxx !=  bs_1 && field_VMPxxxxx !=  bs_2 && field_VMPxxxxx !=  bs_3)) {
  RAW_enc_tree* temp_leaf;
  {
  RAW_enc_tr_pos pr_pos0;
  pr_pos0.level=myleaf.curr_pos.level+1;
  int new_pos0[]={1};
  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_0.RAW_encode(BIT8_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_1.RAW_encode(BIT8_descr_,*temp_leaf);
  } else  {
  RAW_enc_tr_pos pr_pos2;
  pr_pos2.level=myleaf.curr_pos.level+1;
  int new_pos2[]={1};
  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_2.RAW_encode(BIT8_descr_,*temp_leaf);
  } else  {
  RAW_enc_tr_pos pr_pos3;
  pr_pos3.level=myleaf.curr_pos.level+1;
  int new_pos3[]={1};
  pr_pos3.pos=init_new_tree_pos(myleaf.curr_pos,1,new_pos3);
  temp_leaf = myleaf.get_node(pr_pos3);
  if(temp_leaf != NULL){
   bs_3.RAW_encode(BIT8_descr_,*temp_leaf);
  } else {
    TTCN_EncDec_ErrorContext::error
      (TTCN_EncDec::ET_OMITTED_TAG, "Encoding a tagged, but omitted value.");
  }
  free_tree_pos(pr_pos3.pos);
  }
  free_tree_pos(pr_pos2.pos);
  }
  free_tree_pos(pr_pos1.pos);
  }
  free_tree_pos(pr_pos0.pos);
  }
  }
  return myleaf.length = encoded_length;
}

struct Undefined__AVP_template::single_value_struct {
OCTETSTRING_template field_avp__code;
BITSTRING_template field_VMPxxxxx;
INTEGER_template field_avp__length;
OCTETSTRING_template field_vendor__id;
OCTETSTRING_template field_avp__data;
};

void Undefined__AVP_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_avp__code = ANY_VALUE;
single_value->field_VMPxxxxx = ANY_VALUE;
single_value->field_avp__length = ANY_VALUE;
single_value->field_vendor__id = ANY_OR_OMIT;
single_value->field_avp__data = ANY_VALUE;
}
}
}

void Undefined__AVP_template::copy_value(const Undefined__AVP& other_value)
{
single_value = new single_value_struct;
if (other_value.avp__code().is_bound()) {
  single_value->field_avp__code = other_value.avp__code();
} else {
  single_value->field_avp__code.clean_up();
}
if (other_value.VMPxxxxx().is_bound()) {
  single_value->field_VMPxxxxx = other_value.VMPxxxxx();
} else {
  single_value->field_VMPxxxxx.clean_up();
}
if (other_value.avp__length().is_bound()) {
  single_value->field_avp__length = other_value.avp__length();
} else {
  single_value->field_avp__length.clean_up();
}
if (other_value.vendor__id().is_bound()) {
  if (other_value.vendor__id().ispresent()) single_value->field_vendor__id = other_value.vendor__id()();
  else single_value->field_vendor__id = OMIT_VALUE;
} else {
  single_value->field_vendor__id.clean_up();
}
if (other_value.avp__data().is_bound()) {
  single_value->field_avp__data = other_value.avp__data();
} else {
  single_value->field_avp__data.clean_up();
}
set_selection(SPECIFIC_VALUE);
}

void Undefined__AVP_template::copy_template(const Undefined__AVP_template& other_value)
{
switch (other_value.template_selection) {
case SPECIFIC_VALUE:
single_value = new single_value_struct;
if (UNINITIALIZED_TEMPLATE != other_value.avp__code().get_selection()) {
single_value->field_avp__code = other_value.avp__code();
} else {
single_value->field_avp__code.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.VMPxxxxx().get_selection()) {
single_value->field_VMPxxxxx = other_value.VMPxxxxx();
} else {
single_value->field_VMPxxxxx.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.avp__length().get_selection()) {
single_value->field_avp__length = other_value.avp__length();
} else {
single_value->field_avp__length.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.vendor__id().get_selection()) {
single_value->field_vendor__id = other_value.vendor__id();
} else {
single_value->field_vendor__id.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.avp__data().get_selection()) {
single_value->field_avp__data = other_value.avp__data();
} else {
single_value->field_avp__data.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 Undefined__AVP_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 Undefined__AVP_template(*other_value.implication_.precondition);
implication_.implied_template = new Undefined__AVP_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 @DIAMETER_Types.Undefined_AVP.");
break;
}
set_selection(other_value);
}

Undefined__AVP_template::Undefined__AVP_template()
{
}

Undefined__AVP_template::Undefined__AVP_template(template_sel other_value)
 : Base_Template(other_value)
{
check_single_selection(other_value);
}

Undefined__AVP_template::Undefined__AVP_template(const Undefined__AVP& other_value)
{
copy_value(other_value);
}

Undefined__AVP_template::Undefined__AVP_template(const OPTIONAL<Undefined__AVP>& other_value)
{
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const Undefined__AVP&)other_value);
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Creating a template of type @DIAMETER_Types.Undefined_AVP from an unbound optional field.");
}
}

Undefined__AVP_template::Undefined__AVP_template(Undefined__AVP_template* p_precondition, Undefined__AVP_template* p_implied_template)
 : Base_Template(IMPLICATION_MATCH)
{
implication_.precondition = p_precondition;
implication_.implied_template = p_implied_template;
}

Undefined__AVP_template::Undefined__AVP_template(Dynamic_Match_Interface<Undefined__AVP>* p_dyn_match)
 : Base_Template(DYNAMIC_MATCH)
{
dyn_match = new dynmatch_struct<Undefined__AVP>;
dyn_match->ptr = p_dyn_match;
dyn_match->ref_count = 1;
}

Undefined__AVP_template::Undefined__AVP_template(const Undefined__AVP_template& other_value)
: Base_Template()
{
copy_template(other_value);
}

Undefined__AVP_template::~Undefined__AVP_template()
{
clean_up();
}

Undefined__AVP_template& Undefined__AVP_template::operator=(template_sel other_value)
{
check_single_selection(other_value);
clean_up();
set_selection(other_value);
return *this;
}

Undefined__AVP_template& Undefined__AVP_template::operator=(const Undefined__AVP& other_value)
{
clean_up();
copy_value(other_value);
return *this;
}

Undefined__AVP_template& Undefined__AVP_template::operator=(const OPTIONAL<Undefined__AVP>& other_value)
{
clean_up();
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const Undefined__AVP&)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 @DIAMETER_Types.Undefined_AVP.");
}
return *this;
}

Undefined__AVP_template& Undefined__AVP_template::operator=(const Undefined__AVP_template& other_value)
{
if (&other_value != this) {
clean_up();
copy_template(other_value);
}
return *this;
}

boolean Undefined__AVP_template::match(const Undefined__AVP& 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.avp__code().is_bound()) return FALSE;
if(!single_value->field_avp__code.match(other_value.avp__code(), legacy))return FALSE;
if(!other_value.VMPxxxxx().is_bound()) return FALSE;
if(!single_value->field_VMPxxxxx.match(other_value.VMPxxxxx(), legacy))return FALSE;
if(!other_value.avp__length().is_bound()) return FALSE;
if(!single_value->field_avp__length.match(other_value.avp__length(), legacy))return FALSE;
if(!other_value.vendor__id().is_bound()) return FALSE;
if((other_value.vendor__id().ispresent() ? !single_value->field_vendor__id.match((const OCTETSTRING&)other_value.vendor__id(), legacy) : !single_value->field_vendor__id.match_omit(legacy)))return FALSE;
if(!other_value.avp__data().is_bound()) return FALSE;
if(!single_value->field_avp__data.match(other_value.avp__data(), 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 @DIAMETER_Types.Undefined_AVP.");
}
return FALSE;
}

boolean Undefined__AVP_template::is_bound() const
{
if (template_selection == UNINITIALIZED_TEMPLATE && !is_ifpresent) return FALSE;
if (template_selection != SPECIFIC_VALUE) return TRUE;
return single_value->field_avp__code.is_bound()
 || single_value->field_VMPxxxxx.is_bound()
 || single_value->field_avp__length.is_bound()
 || (single_value->field_vendor__id.is_omit() || single_value->field_vendor__id.is_bound())
 || single_value->field_avp__data.is_bound();
}

boolean Undefined__AVP_template::is_value() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE;
return single_value->field_avp__code.is_value()
 && single_value->field_VMPxxxxx.is_value()
 && single_value->field_avp__length.is_value()
 && (single_value->field_vendor__id.is_omit() || single_value->field_vendor__id.is_value())
 && single_value->field_avp__data.is_value();
}

void Undefined__AVP_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;
}

Undefined__AVP Undefined__AVP_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 @DIAMETER_Types.Undefined_AVP.");
Undefined__AVP ret_val;
if (single_value->field_avp__code.is_bound()) {
ret_val.avp__code() = single_value->field_avp__code.valueof();
}
if (single_value->field_VMPxxxxx.is_bound()) {
ret_val.VMPxxxxx() = single_value->field_VMPxxxxx.valueof();
}
if (single_value->field_avp__length.is_bound()) {
ret_val.avp__length() = single_value->field_avp__length.valueof();
}
if (single_value->field_vendor__id.is_omit()) ret_val.vendor__id() = OMIT_VALUE;
else if (single_value->field_vendor__id.is_bound()) {
ret_val.vendor__id() = single_value->field_vendor__id.valueof();
}
if (single_value->field_avp__data.is_bound()) {
ret_val.avp__data() = single_value->field_avp__data.valueof();
}
return ret_val;
}

void Undefined__AVP_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 @DIAMETER_Types.Undefined_AVP.");
clean_up();
set_selection(template_type);
value_list.n_values = list_length;
value_list.list_value = new Undefined__AVP_template[list_length];
}

Undefined__AVP_template& Undefined__AVP_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 @DIAMETER_Types.Undefined_AVP.");
if (list_index >= value_list.n_values)
TTCN_error("Index overflow in a value list template of type @DIAMETER_Types.Undefined_AVP.");
return value_list.list_value[list_index];
}

OCTETSTRING_template& Undefined__AVP_template::avp__code()
{
set_specific();
return single_value->field_avp__code;
}

const OCTETSTRING_template& Undefined__AVP_template::avp__code() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field avp_code of a non-specific template of type @DIAMETER_Types.Undefined_AVP.");
return single_value->field_avp__code;
}

BITSTRING_template& Undefined__AVP_template::VMPxxxxx()
{
set_specific();
return single_value->field_VMPxxxxx;
}

const BITSTRING_template& Undefined__AVP_template::VMPxxxxx() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field VMPxxxxx of a non-specific template of type @DIAMETER_Types.Undefined_AVP.");
return single_value->field_VMPxxxxx;
}

INTEGER_template& Undefined__AVP_template::avp__length()
{
set_specific();
return single_value->field_avp__length;
}

const INTEGER_template& Undefined__AVP_template::avp__length() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field avp_length of a non-specific template of type @DIAMETER_Types.Undefined_AVP.");
return single_value->field_avp__length;
}

OCTETSTRING_template& Undefined__AVP_template::vendor__id()
{
set_specific();
return single_value->field_vendor__id;
}

const OCTETSTRING_template& Undefined__AVP_template::vendor__id() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field vendor_id of a non-specific template of type @DIAMETER_Types.Undefined_AVP.");
return single_value->field_vendor__id;
}

OCTETSTRING_template& Undefined__AVP_template::avp__data()
{
set_specific();
return single_value->field_avp__data;
}

const OCTETSTRING_template& Undefined__AVP_template::avp__data() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field avp_data of a non-specific template of type @DIAMETER_Types.Undefined_AVP.");
return single_value->field_avp__data;
}

int Undefined__AVP_template::size_of() const
{
  if (is_ifpresent) TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.Undefined_AVP which has an ifpresent attribute.");
  switch (template_selection)
  {
  case SPECIFIC_VALUE:
  {    int ret_val = 4;
      if (single_value->field_vendor__id.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 @DIAMETER_Types.Undefined_AVP 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 @DIAMETER_Types.Undefined_AVP containing a value list with different sizes.");
      }
      return item_size;
    }
  case OMIT_VALUE:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.Undefined_AVP containing omit value.");
  case ANY_VALUE:
  case ANY_OR_OMIT:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.Undefined_AVP containing */? value.");
  case COMPLEMENTED_LIST:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.Undefined_AVP containing complemented list.");
  case CONJUNCTION_MATCH:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.Undefined_AVP containing a conjunction list match.");
  case IMPLICATION_MATCH:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.Undefined_AVP containing an implication match.");
  case DYNAMIC_MATCH:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.Undefined_AVP containing a dynamic match.");
  default:
    TTCN_error("Performing sizeof() operation on an uninitialized/unsupported template of type @DIAMETER_Types.Undefined_AVP.");
  }
  return 0;
}

void Undefined__AVP_template::log() const
{
switch (template_selection) {
case SPECIFIC_VALUE:
TTCN_Logger::log_event_str("{ avp_code := ");
single_value->field_avp__code.log();
TTCN_Logger::log_event_str(", VMPxxxxx := ");
single_value->field_VMPxxxxx.log();
TTCN_Logger::log_event_str(", avp_length := ");
single_value->field_avp__length.log();
TTCN_Logger::log_event_str(", vendor_id := ");
single_value->field_vendor__id.log();
TTCN_Logger::log_event_str(", avp_data := ");
single_value->field_avp__data.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 Undefined__AVP_template::log_match(const Undefined__AVP& 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_avp__code.match(match_value.avp__code(), legacy)){
TTCN_Logger::log_logmatch_info(".avp_code");
single_value->field_avp__code.log_match(match_value.avp__code(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if(!single_value->field_VMPxxxxx.match(match_value.VMPxxxxx(), legacy)){
TTCN_Logger::log_logmatch_info(".VMPxxxxx");
single_value->field_VMPxxxxx.log_match(match_value.VMPxxxxx(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if(!single_value->field_avp__length.match(match_value.avp__length(), legacy)){
TTCN_Logger::log_logmatch_info(".avp_length");
single_value->field_avp__length.log_match(match_value.avp__length(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if (match_value.vendor__id().ispresent()){
if(!single_value->field_vendor__id.match(match_value.vendor__id(), legacy)){
TTCN_Logger::log_logmatch_info(".vendor_id");
single_value->field_vendor__id.log_match(match_value.vendor__id(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
} else {
if (!single_value->field_vendor__id.match_omit(legacy)){
 TTCN_Logger::log_logmatch_info(".vendor_id := omit with ");
TTCN_Logger::print_logmatch_buffer();
single_value->field_vendor__id.log();
TTCN_Logger::log_event_str(" unmatched");
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
}
if(!single_value->field_avp__data.match(match_value.avp__data(), legacy)){
TTCN_Logger::log_logmatch_info(".avp_data");
single_value->field_avp__data.log_match(match_value.avp__data(), 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("{ avp_code := ");
single_value->field_avp__code.log_match(match_value.avp__code(), legacy);
TTCN_Logger::log_event_str(", VMPxxxxx := ");
single_value->field_VMPxxxxx.log_match(match_value.VMPxxxxx(), legacy);
TTCN_Logger::log_event_str(", avp_length := ");
single_value->field_avp__length.log_match(match_value.avp__length(), legacy);
TTCN_Logger::log_event_str(", vendor_id := ");
if (match_value.vendor__id().ispresent()) {
single_value->field_vendor__id.log_match(match_value.vendor__id(), legacy);
} else {
TTCN_Logger::log_event_str("omit with ");
single_value->field_vendor__id.log();
if (single_value->field_vendor__id.match_omit(legacy)) TTCN_Logger::log_event_str(" matched");
else TTCN_Logger::log_event_str(" unmatched");
}
TTCN_Logger::log_event_str(", avp_data := ");
single_value->field_avp__data.log_match(match_value.avp__data(), 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 Undefined__AVP_template::set_implicit_omit()
{
if (template_selection != SPECIFIC_VALUE) return;
if (avp__code().is_bound()) avp__code().set_implicit_omit();
if (VMPxxxxx().is_bound()) VMPxxxxx().set_implicit_omit();
if (avp__length().is_bound()) avp__length().set_implicit_omit();
if (!vendor__id().is_bound()) vendor__id() = OMIT_VALUE;
else vendor__id().set_implicit_omit();
if (avp__data().is_bound()) avp__data().set_implicit_omit();
}

void Undefined__AVP_template::encode_text(Text_Buf& text_buf) const
{
encode_text_base(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value->field_avp__code.encode_text(text_buf);
single_value->field_VMPxxxxx.encode_text(text_buf);
single_value->field_avp__length.encode_text(text_buf);
single_value->field_vendor__id.encode_text(text_buf);
single_value->field_avp__data.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 @DIAMETER_Types.Undefined_AVP.");
}
}

void Undefined__AVP_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_avp__code.decode_text(text_buf);
single_value->field_VMPxxxxx.decode_text(text_buf);
single_value->field_avp__length.decode_text(text_buf);
single_value->field_vendor__id.decode_text(text_buf);
single_value->field_avp__data.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 Undefined__AVP_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 @DIAMETER_Types.Undefined_AVP.");
}
}

void Undefined__AVP_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: {
    Undefined__AVP_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_i<param.get_size(); p_i++) {
      new_temp.list_item(p_i).set_param(*param.get_elem(p_i));
    }
    *this = new_temp;
    break; }
  case Module_Param::MP_Value_List:
    if (5<param.get_size()) {
      param.error("record template of type @DIAMETER_Types.Undefined_AVP has 5 fields but list value has %d fields", (int)param.get_size());
    }
    if (param.get_size()>0 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) avp__code().set_param(*param.get_elem(0));
    if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) VMPxxxxx().set_param(*param.get_elem(1));
    if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) avp__length().set_param(*param.get_elem(2));
    if (param.get_size()>3 && param.get_elem(3)->get_type()!=Module_Param::MP_NotUsed) vendor__id().set_param(*param.get_elem(3));
    if (param.get_size()>4 && param.get_elem(4)->get_type()!=Module_Param::MP_NotUsed) avp__data().set_param(*param.get_elem(4));
    break;
  case Module_Param::MP_Assignment_List: {
    Vector<bool> value_used(param.get_size());
    value_used.resize(param.get_size(), FALSE);
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "avp_code")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          avp__code().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "VMPxxxxx")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          VMPxxxxx().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "avp_length")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          avp__length().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "vendor_id")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          vendor__id().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "avp_data")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          avp__data().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) if (!value_used[val_idx]) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      curr_param->error("Non existent field name in type @DIAMETER_Types.Undefined_AVP: %s", curr_param->get_id()->get_name());
      break;
    }
  } break;
  case Module_Param::MP_Implication_Template: {
    Undefined__AVP_template* precondition = new Undefined__AVP_template;
    precondition->set_param(*param.get_elem(0));
    Undefined__AVP_template* implied_template = new Undefined__AVP_template;
    implied_template->set_param(*param.get_elem(1));
    *this = Undefined__AVP_template(precondition, implied_template);
  } break;
  default:
    param.type_error("record template", "@DIAMETER_Types.Undefined_AVP");
  }
  is_ifpresent = param.get_ifpresent();
}

void Undefined__AVP_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_avp__code.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.Undefined_AVP");
single_value->field_VMPxxxxx.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.Undefined_AVP");
single_value->field_avp__length.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.Undefined_AVP");
single_value->field_vendor__id.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.Undefined_AVP");
single_value->field_avp__data.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.Undefined_AVP");
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 : "@DIAMETER_Types.Undefined_AVP");
}

boolean Undefined__AVP_template::is_present(boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE;
return !match_omit(legacy);
}

boolean Undefined__AVP_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<value_list.n_values; l_idx++)
if (value_list.list_value[l_idx].match_omit())
return template_selection==VALUE_LIST;
return template_selection==COMPLEMENTED_LIST;
} // else fall through
default:
return FALSE;
}
return FALSE;
}

Command__Code::Command__Code()
{
enum_value = UNBOUND_VALUE;
}

Command__Code::Command__Code(int other_value)
{
if (!is_valid_enum(other_value)) TTCN_error("Initializing a variable of enumerated type @DIAMETER_Types.Command_Code with invalid numeric value %d.", other_value);
enum_value = (enum_type)other_value;
}

Command__Code::Command__Code(enum_type other_value)
{
enum_value = other_value;
}

Command__Code::Command__Code(const Command__Code& other_value)
: Base_Type()
{
if (other_value.enum_value == UNBOUND_VALUE) TTCN_error("Copying an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
enum_value = other_value.enum_value;
}

Command__Code& Command__Code::operator=(int other_value)
{
if (!is_valid_enum(other_value)) TTCN_error("Assigning unknown numeric value %d to a variable of enumerated type @DIAMETER_Types.Command_Code.", other_value);
enum_value = (enum_type)other_value;
return *this;
}

Command__Code& Command__Code::operator=(enum_type other_value)
{
enum_value = other_value;
return *this;
}

Command__Code& Command__Code::operator=(const Command__Code& other_value)
{
if (other_value.enum_value == UNBOUND_VALUE) TTCN_error("Assignment of an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
enum_value = other_value.enum_value;
return *this;
}

boolean Command__Code::operator==(int other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
if (!is_valid_enum(other_value)) TTCN_error("The right operand of enumerated type @DIAMETER_Types.Command_Code comparison is an unknown numeric value %d", other_value);
return enum_value == other_value;
}

boolean Command__Code::operator==(enum_type other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
return enum_value == other_value;
}

boolean Command__Code::operator==(const Command__Code& other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
if (other_value.enum_value == UNBOUND_VALUE) TTCN_error("The right operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
return enum_value == other_value.enum_value;
}

boolean Command__Code::operator<(int other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
if (!is_valid_enum(other_value)) TTCN_error("The right operand of enumerated type @DIAMETER_Types.Command_Code comparison is an unknown numeric value %d", other_value);
return enum_value < other_value;
}

boolean Command__Code::operator<(enum_type other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
return enum_value < other_value;
}

boolean Command__Code::operator<(const Command__Code& other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
if (other_value.enum_value == UNBOUND_VALUE) TTCN_error("The right operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
return enum_value < other_value.enum_value;
}

boolean Command__Code::operator>(int other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
if (!is_valid_enum(other_value)) TTCN_error("The right operand of enumerated type @DIAMETER_Types.Command_Code comparison is an unknown numeric value %d", other_value);
return enum_value > other_value;
}

boolean Command__Code::operator>(enum_type other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
return enum_value > other_value;
}

boolean Command__Code::operator>(const Command__Code& other_value) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("The left operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
if (other_value.enum_value == UNBOUND_VALUE) TTCN_error("The right operand of comparison is an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
return enum_value > other_value.enum_value;
}

const char *Command__Code::enum_to_str(enum_type enum_par)
{
switch (enum_par) {
case Abort__Session: return "Abort_Session";
case Accounting: return "Accounting";
case Capabilities__Exchange: return "Capabilities_Exchange";
case Device__Watchdog: return "Device_Watchdog";
case Disconnect__Peer: return "Disconnect_Peer";
case Re__Auth: return "Re_Auth";
case Session__Termination: return "Session_Termination";
case Experimental1: return "Experimental1";
case Experimental2: return "Experimental2";
case Authorize__Authenticate: return "Authorize_Authenticate";
case Credit__Control: return "Credit_Control";
case Update__Location: return "Update_Location";
case Cancel__Location: return "Cancel_Location";
case Authentication__Information: return "Authentication_Information";
case Insert__Subscriber__Data: return "Insert_Subscriber_Data";
case Delete__Subscriber__Data: return "Delete_Subscriber_Data";
case Purge__UE: return "Purge_UE";
case Reset: return "Reset";
case Notify: return "Notify";
case ME__Identity__Check: return "ME_Identity_Check";
case Update__VCSG__Location: return "Update_VCSG_Location";
case Cancel__VCSG__Location: return "Cancel_VCSG_Location";
case TDF__Session: return "TDF_Session";
case Subscriber__Information: return "Subscriber_Information";
case Configuration__Information: return "Configuration_Information";
case Reporting__Information: return "Reporting_Information";
case NIDD__Information: return "NIDD_Information";
case User__Authorization: return "User_Authorization";
case Server__Assignment: return "Server_Assignment";
case Location__Info: return "Location_Info";
case Multimedia__Auth: return "Multimedia_Auth";
case Registration__Termination: return "Registration_Termination";
case Push__Profile: return "Push_Profile";
default:
return "<unknown>";
}
}

Command__Code::enum_type Command__Code::str_to_enum(const char *str_par, const int* int_par, const int* int_par2)
{
if (int_par == NULL && int_par2 == NULL) {
if (!strcmp(str_par, "Abort_Session")) return Abort__Session;
if (!strcmp(str_par, "Accounting")) return Accounting;
if (!strcmp(str_par, "Capabilities_Exchange")) return Capabilities__Exchange;
if (!strcmp(str_par, "Device_Watchdog")) return Device__Watchdog;
if (!strcmp(str_par, "Disconnect_Peer")) return Disconnect__Peer;
if (!strcmp(str_par, "Re_Auth")) return Re__Auth;
if (!strcmp(str_par, "Session_Termination")) return Session__Termination;
if (!strcmp(str_par, "Experimental1")) return Experimental1;
if (!strcmp(str_par, "Experimental2")) return Experimental2;
if (!strcmp(str_par, "Authorize_Authenticate")) return Authorize__Authenticate;
if (!strcmp(str_par, "Credit_Control")) return Credit__Control;
if (!strcmp(str_par, "Update_Location")) return Update__Location;
if (!strcmp(str_par, "Cancel_Location")) return Cancel__Location;
if (!strcmp(str_par, "Authentication_Information")) return Authentication__Information;
if (!strcmp(str_par, "Insert_Subscriber_Data")) return Insert__Subscriber__Data;
if (!strcmp(str_par, "Delete_Subscriber_Data")) return Delete__Subscriber__Data;
if (!strcmp(str_par, "Purge_UE")) return Purge__UE;
if (!strcmp(str_par, "Reset")) return Reset;
if (!strcmp(str_par, "Notify")) return Notify;
if (!strcmp(str_par, "ME_Identity_Check")) return ME__Identity__Check;
if (!strcmp(str_par, "Update_VCSG_Location")) return Update__VCSG__Location;
if (!strcmp(str_par, "Cancel_VCSG_Location")) return Cancel__VCSG__Location;
if (!strcmp(str_par, "TDF_Session")) return TDF__Session;
if (!strcmp(str_par, "Subscriber_Information")) return Subscriber__Information;
if (!strcmp(str_par, "Configuration_Information")) return Configuration__Information;
if (!strcmp(str_par, "Reporting_Information")) return Reporting__Information;
if (!strcmp(str_par, "NIDD_Information")) return NIDD__Information;
if (!strcmp(str_par, "User_Authorization")) return User__Authorization;
if (!strcmp(str_par, "Server_Assignment")) return Server__Assignment;
if (!strcmp(str_par, "Location_Info")) return Location__Info;
if (!strcmp(str_par, "Multimedia_Auth")) return Multimedia__Auth;
if (!strcmp(str_par, "Registration_Termination")) return Registration__Termination;
if (!strcmp(str_par, "Push_Profile")) return Push__Profile;
}
return UNKNOWN_VALUE;
}

boolean Command__Code::is_valid_enum(int int_par)
{
switch (int_par) {
case 274:
case 271:
case 257:
case 280:
case 282:
case 258:
case 275:
case 16777214:
case 16777215:
case 265:
case 272:
case 316:
case 317:
case 318:
case 319:
case 320:
case 321:
case 322:
case 323:
case 324:
case 8388638:
case 8388642:
case 8388637:
case 8388641:
case 8388718:
case 8388719:
case 8388726:
case 300:
case 301:
case 302:
case 303:
case 304:
case 305:
return TRUE;
default:
return FALSE;
}
}

int Command__Code::enum2int(enum_type enum_par)
{
if (enum_par==UNBOUND_VALUE || enum_par==UNKNOWN_VALUE) TTCN_error("The argument of function enum2int() is an %s value of enumerated type @DIAMETER_Types.Command_Code.", enum_par==UNBOUND_VALUE?"unbound":"invalid");
return enum_par;
}

int Command__Code::enum2int(const Command__Code& enum_par)
{
if (enum_par.enum_value==UNBOUND_VALUE || enum_par.enum_value==UNKNOWN_VALUE) TTCN_error("The argument of function enum2int() is an %s value of enumerated type @DIAMETER_Types.Command_Code.", enum_par==UNBOUND_VALUE?"unbound":"invalid");
return enum_par.enum_value;
}

void Command__Code::int2enum(int int_val)
{
if (!is_valid_enum(int_val)) TTCN_error("Assigning invalid numeric value %d to a variable of enumerated type @DIAMETER_Types.Command_Code.", int_val);
enum_value = (enum_type)int_val;
}

Command__Code::operator Command__Code::enum_type() const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("Using the value of an unbound variable of enumerated type @DIAMETER_Types.Command_Code.");
return enum_value;
}

void Command__Code::log() const
{
if (enum_value != UNBOUND_VALUE) TTCN_Logger::log_event_enum(enum_to_str(enum_value), enum_value);
else TTCN_Logger::log_event_unbound();
}

void Command__Code::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_VALUE, "enumerated value");
  if (param.get_type()!=Module_Param::MP_Enumerated) param.type_error("enumerated value", "@DIAMETER_Types.Command_Code");
  enum_value = str_to_enum(param.get_enumerated(), param.get_enumerated_value());
  if (!is_valid_enum(enum_value)) {
    param.error("Invalid enumerated value for type @DIAMETER_Types.Command_Code.");
  }
}

void Command__Code::encode_text(Text_Buf& text_buf) const
{
if (enum_value == UNBOUND_VALUE) TTCN_error("Text encoder: Encoding an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
text_buf.push_int(enum_value);
}

void Command__Code::decode_text(Text_Buf& text_buf)
{
enum_value = (enum_type)text_buf.pull_int().get_val();
if (!is_valid_enum(enum_value)) TTCN_error("Text decoder: Unknown numeric value %d was received for enumerated type @DIAMETER_Types.Command_Code.", enum_value);
}

void Command__Code::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;}
  case TTCN_EncDec::CT_PER: {
    TTCN_EncDec_ErrorContext ec("While PER-encoding type '%s': ", p_td.name);
    if (!p_td.per) TTCN_EncDec_ErrorContext::error_internal(
      "No PER descriptor available for type '%s'.", p_td.name);
    int opt = va_arg(pvar, int);
    PER_encode(p_td, p_buf, opt);
    break; }
  default:
    TTCN_error("Unknown coding method requested to encode type '%s'", p_td.name);
  }
  va_end(pvar);
}

void Command__Code::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;}
  case TTCN_EncDec::CT_PER: {
    TTCN_EncDec_ErrorContext ec("While PER-decoding type '%s': ", p_td.name);
    if(!p_td.per)  TTCN_EncDec_ErrorContext::error_internal(
      "No PER descriptor available for type '%s'.", p_td.name);
    int opt = va_arg(pvar, int);
    try {
      PER_decode(p_td, p_buf, opt);
      p_buf.PER_octet_align(FALSE);
    }
    catch (PER_Buffer_Exception) { }
    break; }
  default:
    TTCN_error("Unknown coding method requested to decode type '%s'", p_td.name);
  }
  va_end(pvar);
}

int Command__Code::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*)
{
  int decoded_value = 0;
  int decoded_length = RAW_decode_enum_type(p_td, p_buf, limit, top_bit_ord, decoded_value, 24, no_err);
  if (decoded_length < 0) return decoded_length;
  if (is_valid_enum(decoded_value)) enum_value = (enum_type)decoded_value;
  else {
    if(no_err){
     return -1;
    } else {
    TTCN_EncDec_ErrorContext::error
      (TTCN_EncDec::ET_ENC_ENUM, "Invalid enum value '%d' for '%s': ",decoded_value, p_td.name);
    enum_value = UNKNOWN_VALUE;
    }
  }
  return decoded_length;
}

int Command__Code::RAW_encode(const TTCN_Typedescriptor_t& p_td, RAW_enc_tree& myleaf) const
{
  return RAW_encode_enum_type(p_td, myleaf, (int)enum_value, 24);
}

void Command__Code_template::copy_template(const Command__Code_template& other_value)
{
set_selection(other_value);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value = other_value.single_value;
break;
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 Command__Code_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 Command__Code_template(*other_value.implication_.precondition);
implication_.implied_template = new Command__Code_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 enumerated type @DIAMETER_Types.Command_Code.");
}
}

Command__Code_template::Command__Code_template()
{
}

Command__Code_template::Command__Code_template(template_sel other_value)
 : Base_Template(other_value)
{
check_single_selection(other_value);
}

Command__Code_template::Command__Code_template(int other_value)
 : Base_Template(SPECIFIC_VALUE)
{
if (!Command__Code::is_valid_enum(other_value)) TTCN_error("Initializing a template of enumerated type @DIAMETER_Types.Command_Code with unknown numeric value %d.", other_value);
single_value = (Command__Code::enum_type)other_value;
}

Command__Code_template::Command__Code_template(Command__Code::enum_type other_value)
 : Base_Template(SPECIFIC_VALUE)
{
single_value = other_value;
}

Command__Code_template::Command__Code_template(const Command__Code& other_value)
 : Base_Template(SPECIFIC_VALUE)
{
if (other_value.enum_value == Command__Code::UNBOUND_VALUE) TTCN_error("Creating a template from an unbound value of enumerated type @DIAMETER_Types.Command_Code.");
single_value = other_value.enum_value;
}

Command__Code_template::Command__Code_template(const OPTIONAL<Command__Code>& other_value)
{
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
set_selection(SPECIFIC_VALUE);
single_value = (Command__Code::enum_type)(const Command__Code&)other_value;
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Creating a template of enumerated type @DIAMETER_Types.Command_Code from an unbound optional field.");
}
}

Command__Code_template::Command__Code_template(Command__Code_template* p_precondition, Command__Code_template* p_implied_template)
 : Base_Template(IMPLICATION_MATCH)
{
implication_.precondition = p_precondition;
implication_.implied_template = p_implied_template;
}

Command__Code_template::Command__Code_template(Dynamic_Match_Interface<Command__Code>* p_dyn_match)
 : Base_Template(DYNAMIC_MATCH)
{
dyn_match = new dynmatch_struct<Command__Code>;
dyn_match->ptr = p_dyn_match;
dyn_match->ref_count = 1;
}

Command__Code_template::Command__Code_template(const Command__Code_template& other_value)
 : Base_Template()
{
copy_template(other_value);
}

Command__Code_template::~Command__Code_template()
{
clean_up();
}

boolean Command__Code_template::is_bound() const
{
if (template_selection == UNINITIALIZED_TEMPLATE && !is_ifpresent) return FALSE;
return TRUE;
}

boolean Command__Code_template::is_value() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE;
return single_value != Command__Code::UNBOUND_VALUE;
}

void Command__Code_template::clean_up()
{
switch (template_selection) {
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;
}

Command__Code_template& Command__Code_template::operator=(template_sel other_value)
{
check_single_selection(other_value);
clean_up();
set_selection(other_value);
return *this;
}

Command__Code_template& Command__Code_template::operator=(int other_value)
{
if (!Command__Code::is_valid_enum(other_value)) TTCN_warning("Assigning unknown numeric value %d to a template of enumerated type @DIAMETER_Types.Command_Code.", other_value);
clean_up();
set_selection(SPECIFIC_VALUE);
single_value = (Command__Code::enum_type)other_value;
return *this;
}

Command__Code_template& Command__Code_template::operator=(Command__Code::enum_type other_value)
{
clean_up();
set_selection(SPECIFIC_VALUE);
single_value = other_value;
return *this;
}

Command__Code_template& Command__Code_template::operator=(const Command__Code& other_value)
{
if (other_value.enum_value == Command__Code::UNBOUND_VALUE) TTCN_error("Assignment of an unbound value of enumerated type @DIAMETER_Types.Command_Code to a template.");
clean_up();
set_selection(SPECIFIC_VALUE);
single_value = other_value.enum_value;
return *this;
}

Command__Code_template& Command__Code_template::operator=(const OPTIONAL<Command__Code>& other_value)
{
clean_up();
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
set_selection(SPECIFIC_VALUE);
single_value = (Command__Code::enum_type)(const Command__Code&)other_value;
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Assignment of an unbound optional field to a template of enumerated type @DIAMETER_Types.Command_Code.");
}
return *this;
}

Command__Code_template& Command__Code_template::operator=(const Command__Code_template& other_value)
{
if (&other_value != this) {
clean_up();
copy_template(other_value);
}
return *this;
}

boolean Command__Code_template::match(Command__Code::enum_type other_value, boolean) const
{
switch (template_selection) {
case SPECIFIC_VALUE:
return single_value == other_value;
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)) 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 enumerated type @DIAMETER_Types.Command_Code.");
}
return FALSE;
}

boolean Command__Code_template::match(const Command__Code& other_value, boolean) const
{
if (other_value.enum_value == Command__Code::UNBOUND_VALUE) TTCN_error("Matching a template of enumerated type @DIAMETER_Types.Command_Code with an unbound value.");
return match(other_value.enum_value);
}

Command__Code::enum_type Command__Code_template::valueof() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) TTCN_error("Performing a valueof or send operation on a non-specific template of enumerated type @DIAMETER_Types.Command_Code.");
return single_value;
}

void Command__Code_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:
set_selection(template_type);
value_list.n_values = list_length;
value_list.list_value = new Command__Code_template[list_length];
break;
default:
TTCN_error("Setting an invalid type for a template of enumerated type @DIAMETER_Types.Command_Code.");
}
}

Command__Code_template& Command__Code_template::list_item(unsigned int list_index)
{
if (template_selection != VALUE_LIST && template_selection != COMPLEMENTED_LIST && template_selection != CONJUNCTION_MATCH) TTCN_error("Accessing a list element in a non-list template of enumerated type @DIAMETER_Types.Command_Code.");
if (list_index >= value_list.n_values) TTCN_error("Index overflow in a value list template of enumerated type @DIAMETER_Types.Command_Code.");
return value_list.list_value[list_index];
}

void Command__Code_template::log() const
{
switch (template_selection) {
case SPECIFIC_VALUE:
TTCN_Logger::log_event_enum(Command__Code::enum_to_str(single_value), single_value);
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 elem_count = 0; elem_count < value_list.n_values; elem_count++) {
if (elem_count > 0) TTCN_Logger::log_event_str(", ");
value_list.list_value[elem_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 Command__Code_template::log_match(const Command__Code& match_value, boolean) const
{
match_value.log();
TTCN_Logger::log_event_str(" with ");
log();
if (match(match_value)) TTCN_Logger::log_event_str(" matched");
else TTCN_Logger::log_event_str(" unmatched");
}

void Command__Code_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);
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 elem_count = 0; elem_count < value_list.n_values; elem_count++)
value_list.list_value[elem_count].encode_text(text_buf);
break;
default:
TTCN_error("Text encoder: Encoding an uninitialized/unsupported template of enumerated type @DIAMETER_Types.Command_Code.");
}
}

void Command__Code_template::decode_text(Text_Buf& text_buf)
{
clean_up();
decode_text_base(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value = (Command__Code::enum_type)text_buf.pull_int().get_val();
if (!Command__Code::is_valid_enum(single_value)) TTCN_error("Text decoder: Unknown numeric value %d was received for a template of enumerated type @DIAMETER_Types.Command_Code.", single_value);
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 Command__Code_template[value_list.n_values];
for (unsigned int elem_count = 0; elem_count < value_list.n_values; elem_count++)
value_list.list_value[elem_count].decode_text(text_buf);
break;
default:
TTCN_error("Text decoder: An unknown/unsupported selection was received for a template of enumerated type @DIAMETER_Types.Command_Code.");
}
}

boolean Command__Code_template::is_present(boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE;
return !match_omit(legacy);
}

boolean Command__Code_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; i<value_list.n_values; i++)
if (value_list.list_value[i].match_omit())
return template_selection==VALUE_LIST;
return template_selection==COMPLEMENTED_LIST;
} // else fall through
default:
return FALSE;
}
return FALSE;
}

void Command__Code_template::set_param(Module_Param& param)
{
  param.basic_check(Module_Param::BC_TEMPLATE, "enumerated template");
  Module_Param_Ptr m_p = &param;
  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: {
    Command__Code_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_i<m_p->get_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_Enumerated: {
    Command__Code::enum_type enum_val = Command__Code::str_to_enum(m_p->get_enumerated(), m_p->get_enumerated_value());
    if (!Command__Code::is_valid_enum(enum_val)) {
      param.error("Invalid enumerated value for type @DIAMETER_Types.Command_Code.");
    }
    *this = enum_val;
  } break;
  case Module_Param::MP_Implication_Template: {
    Command__Code_template* precondition = new Command__Code_template;
    precondition->set_param(*m_p->get_elem(0));
    Command__Code_template* implied_template = new Command__Code_template;
    implied_template->set_param(*m_p->get_elem(1));
    *this = Command__Code_template(precondition, implied_template);
  } break;
  default:
    param.type_error("enumerated template", "@DIAMETER_Types.Command_Code");
  }
  is_ifpresent = param.get_ifpresent();
}

void Command__Code_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_VALUE:
if (!is_ifpresent && template_selection==SPECIFIC_VALUE) return;
break;
case TR_OMIT:
if (!is_ifpresent && (template_selection==OMIT_VALUE || template_selection==SPECIFIC_VALUE)) return;
break;
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 : "@DIAMETER_Types.Command_Code");
}

PDU__DIAMETER::PDU__DIAMETER()
{
}

PDU__DIAMETER::PDU__DIAMETER(const INTEGER& par_version,
    const INTEGER& par_message__length,
    const BITSTRING& par_RPETxxxx,
    const Command__Code& par_command__code,
    const OCTETSTRING& par_application__id,
    const OCTETSTRING& par_hop__by__hop__id,
    const OCTETSTRING& par_end__to__end__id,
    const AVP__list& par_avps)
  :   field_version(par_version),
  field_message__length(par_message__length),
  field_RPETxxxx(par_RPETxxxx),
  field_command__code(par_command__code),
  field_application__id(par_application__id),
  field_hop__by__hop__id(par_hop__by__hop__id),
  field_end__to__end__id(par_end__to__end__id),
  field_avps(par_avps)
{
}

PDU__DIAMETER::PDU__DIAMETER(const PDU__DIAMETER& other_value)
{
if(!other_value.is_bound()) TTCN_error("Copying an unbound value of type @DIAMETER_Types.PDU_DIAMETER.");
if (other_value.version().is_bound()) field_version = other_value.version();
else field_version.clean_up();
if (other_value.message__length().is_bound()) field_message__length = other_value.message__length();
else field_message__length.clean_up();
if (other_value.RPETxxxx().is_bound()) field_RPETxxxx = other_value.RPETxxxx();
else field_RPETxxxx.clean_up();
if (other_value.command__code().is_bound()) field_command__code = other_value.command__code();
else field_command__code.clean_up();
if (other_value.application__id().is_bound()) field_application__id = other_value.application__id();
else field_application__id.clean_up();
if (other_value.hop__by__hop__id().is_bound()) field_hop__by__hop__id = other_value.hop__by__hop__id();
else field_hop__by__hop__id.clean_up();
if (other_value.end__to__end__id().is_bound()) field_end__to__end__id = other_value.end__to__end__id();
else field_end__to__end__id.clean_up();
if (other_value.avps().is_bound()) field_avps = other_value.avps();
else field_avps.clean_up();
}

void PDU__DIAMETER::clean_up()
{
field_version.clean_up();
field_message__length.clean_up();
field_RPETxxxx.clean_up();
field_command__code.clean_up();
field_application__id.clean_up();
field_hop__by__hop__id.clean_up();
field_end__to__end__id.clean_up();
field_avps.clean_up();
}

const TTCN_Typedescriptor_t* PDU__DIAMETER::get_descriptor() const { return &PDU__DIAMETER_descr_; }
PDU__DIAMETER& PDU__DIAMETER::operator=(const PDU__DIAMETER& other_value)
{
if (this != &other_value) {
  if(!other_value.is_bound()) TTCN_error("Assignment of an unbound value of type @DIAMETER_Types.PDU_DIAMETER.");
  if (other_value.version().is_bound()) field_version = other_value.version();
  else field_version.clean_up();
  if (other_value.message__length().is_bound()) field_message__length = other_value.message__length();
  else field_message__length.clean_up();
  if (other_value.RPETxxxx().is_bound()) field_RPETxxxx = other_value.RPETxxxx();
  else field_RPETxxxx.clean_up();
  if (other_value.command__code().is_bound()) field_command__code = other_value.command__code();
  else field_command__code.clean_up();
  if (other_value.application__id().is_bound()) field_application__id = other_value.application__id();
  else field_application__id.clean_up();
  if (other_value.hop__by__hop__id().is_bound()) field_hop__by__hop__id = other_value.hop__by__hop__id();
  else field_hop__by__hop__id.clean_up();
  if (other_value.end__to__end__id().is_bound()) field_end__to__end__id = other_value.end__to__end__id();
  else field_end__to__end__id.clean_up();
  if (other_value.avps().is_bound()) field_avps = other_value.avps();
  else field_avps.clean_up();
}
return *this;
}

boolean PDU__DIAMETER::operator==(const PDU__DIAMETER& other_value) const
{
return field_version==other_value.field_version
  && field_message__length==other_value.field_message__length
  && field_RPETxxxx==other_value.field_RPETxxxx
  && field_command__code==other_value.field_command__code
  && field_application__id==other_value.field_application__id
  && field_hop__by__hop__id==other_value.field_hop__by__hop__id
  && field_end__to__end__id==other_value.field_end__to__end__id
  && field_avps==other_value.field_avps;
}

boolean PDU__DIAMETER::is_bound() const
{
return (field_version.is_bound())
  || (field_message__length.is_bound())
  || (field_RPETxxxx.is_bound())
  || (field_command__code.is_bound())
  || (field_application__id.is_bound())
  || (field_hop__by__hop__id.is_bound())
  || (field_end__to__end__id.is_bound())
  || (field_avps.is_bound());
}
boolean PDU__DIAMETER::is_value() const
{
return field_version.is_value()
  && field_message__length.is_value()
  && field_RPETxxxx.is_value()
  && field_command__code.is_value()
  && field_application__id.is_value()
  && field_hop__by__hop__id.is_value()
  && field_end__to__end__id.is_value()
  && field_avps.is_value();
}
void PDU__DIAMETER::log() const
{
if (!is_bound()) {
TTCN_Logger::log_event_unbound();
return;
}
TTCN_Logger::log_event_str("{ version := ");
field_version.log();
TTCN_Logger::log_event_str(", message_length := ");
field_message__length.log();
TTCN_Logger::log_event_str(", RPETxxxx := ");
field_RPETxxxx.log();
TTCN_Logger::log_event_str(", command_code := ");
field_command__code.log();
TTCN_Logger::log_event_str(", application_id := ");
field_application__id.log();
TTCN_Logger::log_event_str(", hop_by_hop_id := ");
field_hop__by__hop__id.log();
TTCN_Logger::log_event_str(", end_to_end_id := ");
field_end__to__end__id.log();
TTCN_Logger::log_event_str(", avps := ");
field_avps.log();
TTCN_Logger::log_event_str(" }");
}

void PDU__DIAMETER::set_implicit_omit()
{
if (version().is_bound()) version().set_implicit_omit();
if (message__length().is_bound()) message__length().set_implicit_omit();
if (RPETxxxx().is_bound()) RPETxxxx().set_implicit_omit();
if (command__code().is_bound()) command__code().set_implicit_omit();
if (application__id().is_bound()) application__id().set_implicit_omit();
if (hop__by__hop__id().is_bound()) hop__by__hop__id().set_implicit_omit();
if (end__to__end__id().is_bound()) end__to__end__id().set_implicit_omit();
if (avps().is_bound()) avps().set_implicit_omit();
}

void PDU__DIAMETER::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 (8<param.get_size()) {
      param.error("record value of type @DIAMETER_Types.PDU_DIAMETER has 8 fields but list value has %d fields", (int)param.get_size());
    }
    if (param.get_size()>0 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) version().set_param(*param.get_elem(0));
    if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) message__length().set_param(*param.get_elem(1));
    if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) RPETxxxx().set_param(*param.get_elem(2));
    if (param.get_size()>3 && param.get_elem(3)->get_type()!=Module_Param::MP_NotUsed) command__code().set_param(*param.get_elem(3));
    if (param.get_size()>4 && param.get_elem(4)->get_type()!=Module_Param::MP_NotUsed) application__id().set_param(*param.get_elem(4));
    if (param.get_size()>5 && param.get_elem(5)->get_type()!=Module_Param::MP_NotUsed) hop__by__hop__id().set_param(*param.get_elem(5));
    if (param.get_size()>6 && param.get_elem(6)->get_type()!=Module_Param::MP_NotUsed) end__to__end__id().set_param(*param.get_elem(6));
    if (param.get_size()>7 && param.get_elem(7)->get_type()!=Module_Param::MP_NotUsed) avps().set_param(*param.get_elem(7));
    break;
  case Module_Param::MP_Assignment_List: {
    Vector<bool> value_used(param.get_size());
    value_used.resize(param.get_size(), FALSE);
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_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_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "message_length")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          message__length().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "RPETxxxx")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          RPETxxxx().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "command_code")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          command__code().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "application_id")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          application__id().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "hop_by_hop_id")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          hop__by__hop__id().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "end_to_end_id")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          end__to__end__id().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "avps")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          avps().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) if (!value_used[val_idx]) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      curr_param->error("Non existent field name in type @DIAMETER_Types.PDU_DIAMETER: %s", curr_param->get_id()->get_name());
      break;
    }
  } break;
  default:
    param.type_error("record value", "@DIAMETER_Types.PDU_DIAMETER");
  }
}

void PDU__DIAMETER::encode_text(Text_Buf& text_buf) const
{
field_version.encode_text(text_buf);
field_message__length.encode_text(text_buf);
field_RPETxxxx.encode_text(text_buf);
field_command__code.encode_text(text_buf);
field_application__id.encode_text(text_buf);
field_hop__by__hop__id.encode_text(text_buf);
field_end__to__end__id.encode_text(text_buf);
field_avps.encode_text(text_buf);
}

void PDU__DIAMETER::decode_text(Text_Buf& text_buf)
{
field_version.decode_text(text_buf);
field_message__length.decode_text(text_buf);
field_RPETxxxx.decode_text(text_buf);
field_command__code.decode_text(text_buf);
field_application__id.decode_text(text_buf);
field_hop__by__hop__id.decode_text(text_buf);
field_end__to__end__id.decode_text(text_buf);
field_avps.decode_text(text_buf);
}

void PDU__DIAMETER::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;}
  case TTCN_EncDec::CT_PER: {
    TTCN_EncDec_ErrorContext ec("While PER-encoding type '%s': ", p_td.name);
    if (!p_td.per) TTCN_EncDec_ErrorContext::error_internal(
      "No PER descriptor available for type '%s'.", p_td.name);
    int opt = va_arg(pvar, int);
    PER_encode(p_td, p_buf, opt);
    break; }
  default:
    TTCN_error("Unknown coding method requested to encode type '%s'", p_td.name);
  }
  va_end(pvar);
}

void PDU__DIAMETER::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;}
  case TTCN_EncDec::CT_PER: {
    TTCN_EncDec_ErrorContext ec("While PER-decoding type '%s': ", p_td.name);
    if(!p_td.per)  TTCN_EncDec_ErrorContext::error_internal(
      "No PER descriptor available for type '%s'.", p_td.name);
    int opt = va_arg(pvar, int);
    try {
      PER_decode(p_td, p_buf, opt);
      p_buf.PER_octet_align(FALSE);
    }
    catch (PER_Buffer_Exception) { }
    break; }
  default:
    TTCN_error("Unknown coding method requested to decode type '%s'", p_td.name);
  }
  va_end(pvar);
}

int PDU__DIAMETER::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_field1 = 0;
  RAW_Force_Omit field_0_force_omit(0, force_omit, UINT8_descr_.raw->forceomit);
  decoded_field_length = field_version.RAW_decode(UINT8_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());
  value_of_length_field1 -= decoded_field_length;
  RAW_Force_Omit field_1_force_omit(1, force_omit, PDU__DIAMETER_message__length_descr_.raw->forceomit);
  decoded_field_length = field_message__length.RAW_decode(PDU__DIAMETER_message__length_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());
  INTEGER tmp1 = field_message__length.convert_to_Integer(PDU__DIAMETER_message__length_descr_);
  field_message__length = tmp1;
  value_of_length_field1 += tmp1.get_long_long_val() * 8;
  value_of_length_field1 -= decoded_field_length;
  if (value_of_length_field1 < 0) return -1;
  RAW_Force_Omit field_2_force_omit(2, force_omit, BIT8_descr_.raw->forceomit);
  decoded_field_length = field_RPETxxxx.RAW_decode(BIT8_descr_, p_buf, min_of_ints(2, limit, value_of_length_field1), 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_field1 -= decoded_field_length;
  RAW_Force_Omit field_3_force_omit(3, force_omit, Command__Code_descr_.raw->forceomit);
  decoded_field_length = field_command__code.RAW_decode(Command__Code_descr_, p_buf, min_of_ints(2, limit, value_of_length_field1), 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());
  value_of_length_field1 -= decoded_field_length;
  RAW_Force_Omit field_4_force_omit(4, force_omit, OCTET4_descr_.raw->forceomit);
  decoded_field_length = field_application__id.RAW_decode(OCTET4_descr_, p_buf, min_of_ints(2, limit, value_of_length_field1), 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());
  value_of_length_field1 -= decoded_field_length;
  RAW_Force_Omit field_5_force_omit(5, force_omit, UINT32_descr_.raw->forceomit);
  decoded_field_length = field_hop__by__hop__id.RAW_decode(UINT32_descr_, p_buf, min_of_ints(2, limit, value_of_length_field1), 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());
  value_of_length_field1 -= decoded_field_length;
  RAW_Force_Omit field_6_force_omit(6, force_omit, UINT32_descr_.raw->forceomit);
  decoded_field_length = field_end__to__end__id.RAW_decode(UINT32_descr_, p_buf, min_of_ints(2, limit, value_of_length_field1), 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());
  value_of_length_field1 -= decoded_field_length;
  RAW_Force_Omit field_7_force_omit(7, force_omit, AVP__list_descr_.raw->forceomit);
  decoded_field_length = field_avps.RAW_decode(AVP__list_descr_, p_buf, min_of_ints(2, limit, value_of_length_field1), 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());
  value_of_length_field1 -= 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__DIAMETER::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 = 8;
  myleaf.body.node.nodes = init_nodes_of_enc_tree(8);
  myleaf.body.node.nodes[0] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 0, UINT8_descr_.raw);
  myleaf.body.node.nodes[1] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 1, PDU__DIAMETER_message__length_descr_.raw);
  myleaf.body.node.nodes[2] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 2, BIT8_descr_.raw);
  myleaf.body.node.nodes[3] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 3, Command__Code_descr_.raw);
  myleaf.body.node.nodes[4] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 4, OCTET4_descr_.raw);
  myleaf.body.node.nodes[5] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 5, UINT32_descr_.raw);
  myleaf.body.node.nodes[6] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 6, UINT32_descr_.raw);
  myleaf.body.node.nodes[7] = new RAW_enc_tree(TRUE, &myleaf, &(myleaf.curr_pos), 7, AVP__list_descr_.raw);
  encoded_length += field_version.RAW_encode(UINT8_descr_, *myleaf.body.node.nodes[0]);
  encoded_length += 24;
  myleaf.body.node.nodes[1]->calc = CALC_LENGTH;
  myleaf.body.node.nodes[1]->coding_descr = &PDU__DIAMETER_message__length_descr_;
  myleaf.body.node.nodes[1]->calcof.lengthto.num_of_fields = 8;
  myleaf.body.node.nodes[1]->calcof.lengthto.unit = 8;
  myleaf.body.node.nodes[1]->calcof.lengthto.offset = 0;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields = init_lengthto_fields_list(8);
  myleaf.body.node.nodes[1]->length = 24;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[0].level = myleaf.body.node.nodes[0]->curr_pos.level;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[0].pos = myleaf.body.node.nodes[0]->curr_pos.pos;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[1].level = myleaf.body.node.nodes[1]->curr_pos.level;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[1].pos = myleaf.body.node.nodes[1]->curr_pos.pos;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[2].level = myleaf.body.node.nodes[2]->curr_pos.level;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[2].pos = myleaf.body.node.nodes[2]->curr_pos.pos;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[3].level = myleaf.body.node.nodes[3]->curr_pos.level;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[3].pos = myleaf.body.node.nodes[3]->curr_pos.pos;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[4].level = myleaf.body.node.nodes[4]->curr_pos.level;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[4].pos = myleaf.body.node.nodes[4]->curr_pos.pos;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[5].level = myleaf.body.node.nodes[5]->curr_pos.level;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[5].pos = myleaf.body.node.nodes[5]->curr_pos.pos;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[6].level = myleaf.body.node.nodes[6]->curr_pos.level;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[6].pos = myleaf.body.node.nodes[6]->curr_pos.pos;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[7].level = myleaf.body.node.nodes[7]->curr_pos.level;
  myleaf.body.node.nodes[1]->calcof.lengthto.fields[7].pos = myleaf.body.node.nodes[7]->curr_pos.pos;
  encoded_length += field_RPETxxxx.RAW_encode(BIT8_descr_, *myleaf.body.node.nodes[2]);
  encoded_length += field_command__code.RAW_encode(Command__Code_descr_, *myleaf.body.node.nodes[3]);
  encoded_length += field_application__id.RAW_encode(OCTET4_descr_, *myleaf.body.node.nodes[4]);
  encoded_length += field_hop__by__hop__id.RAW_encode(UINT32_descr_, *myleaf.body.node.nodes[5]);
  encoded_length += field_end__to__end__id.RAW_encode(UINT32_descr_, *myleaf.body.node.nodes[6]);
  encoded_length += field_avps.RAW_encode(AVP__list_descr_, *myleaf.body.node.nodes[7]);
  return myleaf.length = encoded_length;
}

struct PDU__DIAMETER_template::single_value_struct {
INTEGER_template field_version;
INTEGER_template field_message__length;
BITSTRING_template field_RPETxxxx;
Command__Code_template field_command__code;
OCTETSTRING_template field_application__id;
OCTETSTRING_template field_hop__by__hop__id;
OCTETSTRING_template field_end__to__end__id;
AVP__list_template field_avps;
};

void PDU__DIAMETER_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_version = ANY_VALUE;
single_value->field_message__length = ANY_VALUE;
single_value->field_RPETxxxx = ANY_VALUE;
single_value->field_command__code = ANY_VALUE;
single_value->field_application__id = ANY_VALUE;
single_value->field_hop__by__hop__id = ANY_VALUE;
single_value->field_end__to__end__id = ANY_VALUE;
single_value->field_avps = ANY_VALUE;
}
}
}

void PDU__DIAMETER_template::copy_value(const PDU__DIAMETER& other_value)
{
single_value = new single_value_struct;
if (other_value.version().is_bound()) {
  single_value->field_version = other_value.version();
} else {
  single_value->field_version.clean_up();
}
if (other_value.message__length().is_bound()) {
  single_value->field_message__length = other_value.message__length();
} else {
  single_value->field_message__length.clean_up();
}
if (other_value.RPETxxxx().is_bound()) {
  single_value->field_RPETxxxx = other_value.RPETxxxx();
} else {
  single_value->field_RPETxxxx.clean_up();
}
if (other_value.command__code().is_bound()) {
  single_value->field_command__code = other_value.command__code();
} else {
  single_value->field_command__code.clean_up();
}
if (other_value.application__id().is_bound()) {
  single_value->field_application__id = other_value.application__id();
} else {
  single_value->field_application__id.clean_up();
}
if (other_value.hop__by__hop__id().is_bound()) {
  single_value->field_hop__by__hop__id = other_value.hop__by__hop__id();
} else {
  single_value->field_hop__by__hop__id.clean_up();
}
if (other_value.end__to__end__id().is_bound()) {
  single_value->field_end__to__end__id = other_value.end__to__end__id();
} else {
  single_value->field_end__to__end__id.clean_up();
}
if (other_value.avps().is_bound()) {
  single_value->field_avps = other_value.avps();
} else {
  single_value->field_avps.clean_up();
}
set_selection(SPECIFIC_VALUE);
}

void PDU__DIAMETER_template::copy_template(const PDU__DIAMETER_template& other_value)
{
switch (other_value.template_selection) {
case SPECIFIC_VALUE:
single_value = new single_value_struct;
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.message__length().get_selection()) {
single_value->field_message__length = other_value.message__length();
} else {
single_value->field_message__length.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.RPETxxxx().get_selection()) {
single_value->field_RPETxxxx = other_value.RPETxxxx();
} else {
single_value->field_RPETxxxx.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.command__code().get_selection()) {
single_value->field_command__code = other_value.command__code();
} else {
single_value->field_command__code.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.application__id().get_selection()) {
single_value->field_application__id = other_value.application__id();
} else {
single_value->field_application__id.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.hop__by__hop__id().get_selection()) {
single_value->field_hop__by__hop__id = other_value.hop__by__hop__id();
} else {
single_value->field_hop__by__hop__id.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.end__to__end__id().get_selection()) {
single_value->field_end__to__end__id = other_value.end__to__end__id();
} else {
single_value->field_end__to__end__id.clean_up();
}
if (UNINITIALIZED_TEMPLATE != other_value.avps().get_selection()) {
single_value->field_avps = other_value.avps();
} else {
single_value->field_avps.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__DIAMETER_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__DIAMETER_template(*other_value.implication_.precondition);
implication_.implied_template = new PDU__DIAMETER_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 @DIAMETER_Types.PDU_DIAMETER.");
break;
}
set_selection(other_value);
}

PDU__DIAMETER_template::PDU__DIAMETER_template()
{
}

PDU__DIAMETER_template::PDU__DIAMETER_template(template_sel other_value)
 : Base_Template(other_value)
{
check_single_selection(other_value);
}

PDU__DIAMETER_template::PDU__DIAMETER_template(const PDU__DIAMETER& other_value)
{
copy_value(other_value);
}

PDU__DIAMETER_template::PDU__DIAMETER_template(const OPTIONAL<PDU__DIAMETER>& other_value)
{
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const PDU__DIAMETER&)other_value);
break;
case OPTIONAL_OMIT:
set_selection(OMIT_VALUE);
break;
default:
TTCN_error("Creating a template of type @DIAMETER_Types.PDU_DIAMETER from an unbound optional field.");
}
}

PDU__DIAMETER_template::PDU__DIAMETER_template(PDU__DIAMETER_template* p_precondition, PDU__DIAMETER_template* p_implied_template)
 : Base_Template(IMPLICATION_MATCH)
{
implication_.precondition = p_precondition;
implication_.implied_template = p_implied_template;
}

PDU__DIAMETER_template::PDU__DIAMETER_template(Dynamic_Match_Interface<PDU__DIAMETER>* p_dyn_match)
 : Base_Template(DYNAMIC_MATCH)
{
dyn_match = new dynmatch_struct<PDU__DIAMETER>;
dyn_match->ptr = p_dyn_match;
dyn_match->ref_count = 1;
}

PDU__DIAMETER_template::PDU__DIAMETER_template(const PDU__DIAMETER_template& other_value)
: Base_Template()
{
copy_template(other_value);
}

PDU__DIAMETER_template::~PDU__DIAMETER_template()
{
clean_up();
}

PDU__DIAMETER_template& PDU__DIAMETER_template::operator=(template_sel other_value)
{
check_single_selection(other_value);
clean_up();
set_selection(other_value);
return *this;
}

PDU__DIAMETER_template& PDU__DIAMETER_template::operator=(const PDU__DIAMETER& other_value)
{
clean_up();
copy_value(other_value);
return *this;
}

PDU__DIAMETER_template& PDU__DIAMETER_template::operator=(const OPTIONAL<PDU__DIAMETER>& other_value)
{
clean_up();
switch (other_value.get_selection()) {
case OPTIONAL_PRESENT:
copy_value((const PDU__DIAMETER&)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 @DIAMETER_Types.PDU_DIAMETER.");
}
return *this;
}

PDU__DIAMETER_template& PDU__DIAMETER_template::operator=(const PDU__DIAMETER_template& other_value)
{
if (&other_value != this) {
clean_up();
copy_template(other_value);
}
return *this;
}

boolean PDU__DIAMETER_template::match(const PDU__DIAMETER& 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.version().is_bound()) return FALSE;
if(!single_value->field_version.match(other_value.version(), legacy))return FALSE;
if(!other_value.message__length().is_bound()) return FALSE;
if(!single_value->field_message__length.match(other_value.message__length(), legacy))return FALSE;
if(!other_value.RPETxxxx().is_bound()) return FALSE;
if(!single_value->field_RPETxxxx.match(other_value.RPETxxxx(), legacy))return FALSE;
if(!other_value.command__code().is_bound()) return FALSE;
if(!single_value->field_command__code.match(other_value.command__code(), legacy))return FALSE;
if(!other_value.application__id().is_bound()) return FALSE;
if(!single_value->field_application__id.match(other_value.application__id(), legacy))return FALSE;
if(!other_value.hop__by__hop__id().is_bound()) return FALSE;
if(!single_value->field_hop__by__hop__id.match(other_value.hop__by__hop__id(), legacy))return FALSE;
if(!other_value.end__to__end__id().is_bound()) return FALSE;
if(!single_value->field_end__to__end__id.match(other_value.end__to__end__id(), legacy))return FALSE;
if(!other_value.avps().is_bound()) return FALSE;
if(!single_value->field_avps.match(other_value.avps(), 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 @DIAMETER_Types.PDU_DIAMETER.");
}
return FALSE;
}

boolean PDU__DIAMETER_template::is_bound() const
{
if (template_selection == UNINITIALIZED_TEMPLATE && !is_ifpresent) return FALSE;
if (template_selection != SPECIFIC_VALUE) return TRUE;
return single_value->field_version.is_bound()
 || single_value->field_message__length.is_bound()
 || single_value->field_RPETxxxx.is_bound()
 || single_value->field_command__code.is_bound()
 || single_value->field_application__id.is_bound()
 || single_value->field_hop__by__hop__id.is_bound()
 || single_value->field_end__to__end__id.is_bound()
 || single_value->field_avps.is_bound();
}

boolean PDU__DIAMETER_template::is_value() const
{
if (template_selection != SPECIFIC_VALUE || is_ifpresent) return FALSE;
return single_value->field_version.is_value()
 && single_value->field_message__length.is_value()
 && single_value->field_RPETxxxx.is_value()
 && single_value->field_command__code.is_value()
 && single_value->field_application__id.is_value()
 && single_value->field_hop__by__hop__id.is_value()
 && single_value->field_end__to__end__id.is_value()
 && single_value->field_avps.is_value();
}

void PDU__DIAMETER_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__DIAMETER PDU__DIAMETER_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 @DIAMETER_Types.PDU_DIAMETER.");
PDU__DIAMETER ret_val;
if (single_value->field_version.is_bound()) {
ret_val.version() = single_value->field_version.valueof();
}
if (single_value->field_message__length.is_bound()) {
ret_val.message__length() = single_value->field_message__length.valueof();
}
if (single_value->field_RPETxxxx.is_bound()) {
ret_val.RPETxxxx() = single_value->field_RPETxxxx.valueof();
}
if (single_value->field_command__code.is_bound()) {
ret_val.command__code() = single_value->field_command__code.valueof();
}
if (single_value->field_application__id.is_bound()) {
ret_val.application__id() = single_value->field_application__id.valueof();
}
if (single_value->field_hop__by__hop__id.is_bound()) {
ret_val.hop__by__hop__id() = single_value->field_hop__by__hop__id.valueof();
}
if (single_value->field_end__to__end__id.is_bound()) {
ret_val.end__to__end__id() = single_value->field_end__to__end__id.valueof();
}
if (single_value->field_avps.is_bound()) {
ret_val.avps() = single_value->field_avps.valueof();
}
return ret_val;
}

void PDU__DIAMETER_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 @DIAMETER_Types.PDU_DIAMETER.");
clean_up();
set_selection(template_type);
value_list.n_values = list_length;
value_list.list_value = new PDU__DIAMETER_template[list_length];
}

PDU__DIAMETER_template& PDU__DIAMETER_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 @DIAMETER_Types.PDU_DIAMETER.");
if (list_index >= value_list.n_values)
TTCN_error("Index overflow in a value list template of type @DIAMETER_Types.PDU_DIAMETER.");
return value_list.list_value[list_index];
}

INTEGER_template& PDU__DIAMETER_template::version()
{
set_specific();
return single_value->field_version;
}

const INTEGER_template& PDU__DIAMETER_template::version() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field version of a non-specific template of type @DIAMETER_Types.PDU_DIAMETER.");
return single_value->field_version;
}

INTEGER_template& PDU__DIAMETER_template::message__length()
{
set_specific();
return single_value->field_message__length;
}

const INTEGER_template& PDU__DIAMETER_template::message__length() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field message_length of a non-specific template of type @DIAMETER_Types.PDU_DIAMETER.");
return single_value->field_message__length;
}

BITSTRING_template& PDU__DIAMETER_template::RPETxxxx()
{
set_specific();
return single_value->field_RPETxxxx;
}

const BITSTRING_template& PDU__DIAMETER_template::RPETxxxx() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field RPETxxxx of a non-specific template of type @DIAMETER_Types.PDU_DIAMETER.");
return single_value->field_RPETxxxx;
}

Command__Code_template& PDU__DIAMETER_template::command__code()
{
set_specific();
return single_value->field_command__code;
}

const Command__Code_template& PDU__DIAMETER_template::command__code() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field command_code of a non-specific template of type @DIAMETER_Types.PDU_DIAMETER.");
return single_value->field_command__code;
}

OCTETSTRING_template& PDU__DIAMETER_template::application__id()
{
set_specific();
return single_value->field_application__id;
}

const OCTETSTRING_template& PDU__DIAMETER_template::application__id() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field application_id of a non-specific template of type @DIAMETER_Types.PDU_DIAMETER.");
return single_value->field_application__id;
}

OCTETSTRING_template& PDU__DIAMETER_template::hop__by__hop__id()
{
set_specific();
return single_value->field_hop__by__hop__id;
}

const OCTETSTRING_template& PDU__DIAMETER_template::hop__by__hop__id() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field hop_by_hop_id of a non-specific template of type @DIAMETER_Types.PDU_DIAMETER.");
return single_value->field_hop__by__hop__id;
}

OCTETSTRING_template& PDU__DIAMETER_template::end__to__end__id()
{
set_specific();
return single_value->field_end__to__end__id;
}

const OCTETSTRING_template& PDU__DIAMETER_template::end__to__end__id() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field end_to_end_id of a non-specific template of type @DIAMETER_Types.PDU_DIAMETER.");
return single_value->field_end__to__end__id;
}

AVP__list_template& PDU__DIAMETER_template::avps()
{
set_specific();
return single_value->field_avps;
}

const AVP__list_template& PDU__DIAMETER_template::avps() const
{
if (template_selection != SPECIFIC_VALUE)
TTCN_error("Accessing field avps of a non-specific template of type @DIAMETER_Types.PDU_DIAMETER.");
return single_value->field_avps;
}

int PDU__DIAMETER_template::size_of() const
{
  if (is_ifpresent) TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.PDU_DIAMETER which has an ifpresent attribute.");
  switch (template_selection)
  {
  case SPECIFIC_VALUE:
    return 8;
  case VALUE_LIST:
   {
     if (value_list.n_values<1)
       TTCN_error("Internal error: Performing sizeof() operation on a template of type @DIAMETER_Types.PDU_DIAMETER 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 @DIAMETER_Types.PDU_DIAMETER containing a value list with different sizes.");
      }
      return item_size;
    }
  case OMIT_VALUE:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.PDU_DIAMETER containing omit value.");
  case ANY_VALUE:
  case ANY_OR_OMIT:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.PDU_DIAMETER containing */? value.");
  case COMPLEMENTED_LIST:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.PDU_DIAMETER containing complemented list.");
  case CONJUNCTION_MATCH:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.PDU_DIAMETER containing a conjunction list match.");
  case IMPLICATION_MATCH:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.PDU_DIAMETER containing an implication match.");
  case DYNAMIC_MATCH:
    TTCN_error("Performing sizeof() operation on a template of type @DIAMETER_Types.PDU_DIAMETER containing a dynamic match.");
  default:
    TTCN_error("Performing sizeof() operation on an uninitialized/unsupported template of type @DIAMETER_Types.PDU_DIAMETER.");
  }
  return 0;
}

void PDU__DIAMETER_template::log() const
{
switch (template_selection) {
case SPECIFIC_VALUE:
TTCN_Logger::log_event_str("{ version := ");
single_value->field_version.log();
TTCN_Logger::log_event_str(", message_length := ");
single_value->field_message__length.log();
TTCN_Logger::log_event_str(", RPETxxxx := ");
single_value->field_RPETxxxx.log();
TTCN_Logger::log_event_str(", command_code := ");
single_value->field_command__code.log();
TTCN_Logger::log_event_str(", application_id := ");
single_value->field_application__id.log();
TTCN_Logger::log_event_str(", hop_by_hop_id := ");
single_value->field_hop__by__hop__id.log();
TTCN_Logger::log_event_str(", end_to_end_id := ");
single_value->field_end__to__end__id.log();
TTCN_Logger::log_event_str(", avps := ");
single_value->field_avps.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__DIAMETER_template::log_match(const PDU__DIAMETER& 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_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_message__length.match(match_value.message__length(), legacy)){
TTCN_Logger::log_logmatch_info(".message_length");
single_value->field_message__length.log_match(match_value.message__length(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if(!single_value->field_RPETxxxx.match(match_value.RPETxxxx(), legacy)){
TTCN_Logger::log_logmatch_info(".RPETxxxx");
single_value->field_RPETxxxx.log_match(match_value.RPETxxxx(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if(!single_value->field_command__code.match(match_value.command__code(), legacy)){
TTCN_Logger::log_logmatch_info(".command_code");
single_value->field_command__code.log_match(match_value.command__code(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if(!single_value->field_application__id.match(match_value.application__id(), legacy)){
TTCN_Logger::log_logmatch_info(".application_id");
single_value->field_application__id.log_match(match_value.application__id(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if(!single_value->field_hop__by__hop__id.match(match_value.hop__by__hop__id(), legacy)){
TTCN_Logger::log_logmatch_info(".hop_by_hop_id");
single_value->field_hop__by__hop__id.log_match(match_value.hop__by__hop__id(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if(!single_value->field_end__to__end__id.match(match_value.end__to__end__id(), legacy)){
TTCN_Logger::log_logmatch_info(".end_to_end_id");
single_value->field_end__to__end__id.log_match(match_value.end__to__end__id(), legacy);
TTCN_Logger::set_logmatch_buffer_len(previous_size);
}
if(!single_value->field_avps.match(match_value.avps(), legacy)){
TTCN_Logger::log_logmatch_info(".avps");
single_value->field_avps.log_match(match_value.avps(), 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("{ version := ");
single_value->field_version.log_match(match_value.version(), legacy);
TTCN_Logger::log_event_str(", message_length := ");
single_value->field_message__length.log_match(match_value.message__length(), legacy);
TTCN_Logger::log_event_str(", RPETxxxx := ");
single_value->field_RPETxxxx.log_match(match_value.RPETxxxx(), legacy);
TTCN_Logger::log_event_str(", command_code := ");
single_value->field_command__code.log_match(match_value.command__code(), legacy);
TTCN_Logger::log_event_str(", application_id := ");
single_value->field_application__id.log_match(match_value.application__id(), legacy);
TTCN_Logger::log_event_str(", hop_by_hop_id := ");
single_value->field_hop__by__hop__id.log_match(match_value.hop__by__hop__id(), legacy);
TTCN_Logger::log_event_str(", end_to_end_id := ");
single_value->field_end__to__end__id.log_match(match_value.end__to__end__id(), legacy);
TTCN_Logger::log_event_str(", avps := ");
single_value->field_avps.log_match(match_value.avps(), 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__DIAMETER_template::set_implicit_omit()
{
if (template_selection != SPECIFIC_VALUE) return;
if (version().is_bound()) version().set_implicit_omit();
if (message__length().is_bound()) message__length().set_implicit_omit();
if (RPETxxxx().is_bound()) RPETxxxx().set_implicit_omit();
if (command__code().is_bound()) command__code().set_implicit_omit();
if (application__id().is_bound()) application__id().set_implicit_omit();
if (hop__by__hop__id().is_bound()) hop__by__hop__id().set_implicit_omit();
if (end__to__end__id().is_bound()) end__to__end__id().set_implicit_omit();
if (avps().is_bound()) avps().set_implicit_omit();
}

void PDU__DIAMETER_template::encode_text(Text_Buf& text_buf) const
{
encode_text_base(text_buf);
switch (template_selection) {
case SPECIFIC_VALUE:
single_value->field_version.encode_text(text_buf);
single_value->field_message__length.encode_text(text_buf);
single_value->field_RPETxxxx.encode_text(text_buf);
single_value->field_command__code.encode_text(text_buf);
single_value->field_application__id.encode_text(text_buf);
single_value->field_hop__by__hop__id.encode_text(text_buf);
single_value->field_end__to__end__id.encode_text(text_buf);
single_value->field_avps.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 @DIAMETER_Types.PDU_DIAMETER.");
}
}

void PDU__DIAMETER_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_version.decode_text(text_buf);
single_value->field_message__length.decode_text(text_buf);
single_value->field_RPETxxxx.decode_text(text_buf);
single_value->field_command__code.decode_text(text_buf);
single_value->field_application__id.decode_text(text_buf);
single_value->field_hop__by__hop__id.decode_text(text_buf);
single_value->field_end__to__end__id.decode_text(text_buf);
single_value->field_avps.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__DIAMETER_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 @DIAMETER_Types.PDU_DIAMETER.");
}
}

void PDU__DIAMETER_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__DIAMETER_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_i<param.get_size(); p_i++) {
      new_temp.list_item(p_i).set_param(*param.get_elem(p_i));
    }
    *this = new_temp;
    break; }
  case Module_Param::MP_Value_List:
    if (8<param.get_size()) {
      param.error("record template of type @DIAMETER_Types.PDU_DIAMETER has 8 fields but list value has %d fields", (int)param.get_size());
    }
    if (param.get_size()>0 && param.get_elem(0)->get_type()!=Module_Param::MP_NotUsed) version().set_param(*param.get_elem(0));
    if (param.get_size()>1 && param.get_elem(1)->get_type()!=Module_Param::MP_NotUsed) message__length().set_param(*param.get_elem(1));
    if (param.get_size()>2 && param.get_elem(2)->get_type()!=Module_Param::MP_NotUsed) RPETxxxx().set_param(*param.get_elem(2));
    if (param.get_size()>3 && param.get_elem(3)->get_type()!=Module_Param::MP_NotUsed) command__code().set_param(*param.get_elem(3));
    if (param.get_size()>4 && param.get_elem(4)->get_type()!=Module_Param::MP_NotUsed) application__id().set_param(*param.get_elem(4));
    if (param.get_size()>5 && param.get_elem(5)->get_type()!=Module_Param::MP_NotUsed) hop__by__hop__id().set_param(*param.get_elem(5));
    if (param.get_size()>6 && param.get_elem(6)->get_type()!=Module_Param::MP_NotUsed) end__to__end__id().set_param(*param.get_elem(6));
    if (param.get_size()>7 && param.get_elem(7)->get_type()!=Module_Param::MP_NotUsed) avps().set_param(*param.get_elem(7));
    break;
  case Module_Param::MP_Assignment_List: {
    Vector<bool> value_used(param.get_size());
    value_used.resize(param.get_size(), FALSE);
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_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_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "message_length")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          message__length().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "RPETxxxx")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          RPETxxxx().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "command_code")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          command__code().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "application_id")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          application__id().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "hop_by_hop_id")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          hop__by__hop__id().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "end_to_end_id")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          end__to__end__id().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      if (!strcmp(curr_param->get_id()->get_name(), "avps")) {
        if (curr_param->get_type()!=Module_Param::MP_NotUsed) {
          avps().set_param(*curr_param);
        }
        value_used[val_idx]=TRUE;
      }
    }
    for (size_t val_idx=0; val_idx<param.get_size(); val_idx++) if (!value_used[val_idx]) {
      Module_Param* const curr_param = param.get_elem(val_idx);
      curr_param->error("Non existent field name in type @DIAMETER_Types.PDU_DIAMETER: %s", curr_param->get_id()->get_name());
      break;
    }
  } break;
  case Module_Param::MP_Implication_Template: {
    PDU__DIAMETER_template* precondition = new PDU__DIAMETER_template;
    precondition->set_param(*param.get_elem(0));
    PDU__DIAMETER_template* implied_template = new PDU__DIAMETER_template;
    implied_template->set_param(*param.get_elem(1));
    *this = PDU__DIAMETER_template(precondition, implied_template);
  } break;
  default:
    param.type_error("record template", "@DIAMETER_Types.PDU_DIAMETER");
  }
  is_ifpresent = param.get_ifpresent();
}

void PDU__DIAMETER_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_version.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.PDU_DIAMETER");
single_value->field_message__length.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.PDU_DIAMETER");
single_value->field_RPETxxxx.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.PDU_DIAMETER");
single_value->field_command__code.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.PDU_DIAMETER");
single_value->field_application__id.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.PDU_DIAMETER");
single_value->field_hop__by__hop__id.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.PDU_DIAMETER");
single_value->field_end__to__end__id.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.PDU_DIAMETER");
single_value->field_avps.check_restriction(t_res, t_name ? t_name : "@DIAMETER_Types.PDU_DIAMETER");
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 : "@DIAMETER_Types.PDU_DIAMETER");
}

boolean PDU__DIAMETER_template::is_present(boolean legacy) const
{
if (template_selection==UNINITIALIZED_TEMPLATE) return FALSE;
return !match_omit(legacy);
}

boolean PDU__DIAMETER_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<value_list.n_values; l_idx++)
if (value_list.list_value[l_idx].match_omit())
return template_selection==VALUE_LIST;
return template_selection==COMPLEMENTED_LIST;
} // else fall through
default:
return FALSE;
}
return FALSE;
}


/* Bodies of functions, altsteps and testcases */

void UINT32_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(UINT32_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER UINT32_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(UINT32_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void BASE__NONE__Accounting__Realtime__Required_encoder(const BASE__NONE__Accounting__Realtime__Required& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Accounting_Realtime_Required' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(BASE__NONE__Accounting__Realtime__Required_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Accounting__Realtime__Required_decoder(OCTETSTRING& input_stream, BASE__NONE__Accounting__Realtime__Required& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Accounting_Realtime_Required' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(BASE__NONE__Accounting__Realtime__Required_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void UTF8_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 UTF8_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 BASE__NONE__Accounting__Record__Type_encoder(const BASE__NONE__Accounting__Record__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Accounting_Record_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(BASE__NONE__Accounting__Record__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Accounting__Record__Type_decoder(OCTETSTRING& input_stream, BASE__NONE__Accounting__Record__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Accounting_Record_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(BASE__NONE__Accounting__Record__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AVP__OctetString_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 AVP__OctetString_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 UINT64_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(UINT64_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER UINT64_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(UINT64_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void BASE__NONE__Auth__Request__Type_encoder(const BASE__NONE__Auth__Request__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Auth_Request_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(BASE__NONE__Auth__Request__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Auth__Request__Type_decoder(OCTETSTRING& input_stream, BASE__NONE__Auth__Request__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Auth_Request_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(BASE__NONE__Auth__Request__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void BASE__NONE__Auth__Session__State_encoder(const BASE__NONE__Auth__Session__State& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Auth_Session_State' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(BASE__NONE__Auth__Session__State_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Auth__Session__State_decoder(OCTETSTRING& input_stream, BASE__NONE__Auth__Session__State& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Auth_Session_State' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(BASE__NONE__Auth__Session__State_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void BASE__NONE__Re__Auth__Request__Type_encoder(const BASE__NONE__Re__Auth__Request__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Re_Auth_Request_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(BASE__NONE__Re__Auth__Request__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Re__Auth__Request__Type_decoder(OCTETSTRING& input_stream, BASE__NONE__Re__Auth__Request__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Re_Auth_Request_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(BASE__NONE__Re__Auth__Request__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DiameterIdentity_encoder(const CHARSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `charstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CHARSTRING_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DiameterIdentity_decoder(OCTETSTRING& input_stream, CHARSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `charstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CHARSTRING_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void BASE__NONE__Disconnect__Cause_encoder(const BASE__NONE__Disconnect__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 `@DIAMETER_Types.BASE_NONE_Disconnect_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(BASE__NONE__Disconnect__Cause_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Disconnect__Cause_decoder(OCTETSTRING& input_stream, BASE__NONE__Disconnect__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 `@DIAMETER_Types.BASE_NONE_Disconnect_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(BASE__NONE__Disconnect__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;
}
}

boolean operator==(null_type, const AVP__list& other_value)
{
if (other_value.val_ptr == NULL)
TTCN_error("The right operand of comparison is an unbound value of type @DIAMETER_Types.AVP_list.");
return other_value.val_ptr->n_elements == 0;
}

void AVP__Code__ETSI_encoder(const AVP__Code__ETSI& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Code_ETSI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__Code__ETSI_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__Code__ETSI_decoder(OCTETSTRING& input_stream, AVP__Code__ETSI& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Code_ETSI' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__Code__ETSI_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AVP__Code__NONE_encoder(const AVP__Code__NONE& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Code_NONE' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__Code__NONE_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__Code__NONE_decoder(OCTETSTRING& input_stream, AVP__Code__NONE& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Code_NONE' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__Code__NONE_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AVP__Code__3GPP_encoder(const AVP__Code__3GPP& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Code_3GPP' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__Code__3GPP_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__Code__3GPP_decoder(OCTETSTRING& input_stream, AVP__Code__3GPP& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Code_3GPP' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__Code__3GPP_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AVP__Code_encoder(const AVP__Code& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__Code_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__Code_decoder(OCTETSTRING& input_stream, AVP__Code& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__Code_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AVP__Header_avp__code_encoder(const AVP__Code& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__Header_avp__code_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__Header_avp__code_decoder(OCTETSTRING& input_stream, AVP__Code& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__Header_avp__code_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void BIT8_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(BIT8_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BIT8_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(BIT8_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void UINT24_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(UINT24_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER UINT24_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(UINT24_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void Vendor__Id_encoder(const Vendor__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 `@DIAMETER_Types.Vendor_Id' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(Vendor__Id_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER Vendor__Id_decoder(OCTETSTRING& input_stream, Vendor__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 `@DIAMETER_Types.Vendor_Id' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(Vendor__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 AVP__Header_vendor__id_encoder(const Vendor__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 `@DIAMETER_Types.Vendor_Id' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__Header_vendor__id_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__Header_vendor__id_decoder(OCTETSTRING& input_stream, Vendor__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 `@DIAMETER_Types.Vendor_Id' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__Header_vendor__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 AVP__Header_encoder(const AVP__Header& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Header' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__Header_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__Header_decoder(OCTETSTRING& input_stream, AVP__Header& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Header' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__Header_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AVP_avp__header_encoder(const AVP__Header& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Header' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP_avp__header_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP_avp__header_decoder(OCTETSTRING& input_stream, AVP__Header& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Header' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP_avp__header_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AddressType_encoder(const AddressType& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AddressType' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AddressType_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AddressType_decoder(OCTETSTRING& input_stream, AddressType& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AddressType' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AddressType_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AVP__Address_address__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 AVP__Address_address__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 AVP__Address_encoder(const AVP__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 `@DIAMETER_Types.AVP_Address' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__Address_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__Address_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_Address' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Direct__Debiting__Failure__Handling_encoder(const DCC__NONE__Direct__Debiting__Failure__Handling& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Direct_Debiting_Failure_Handling' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__Direct__Debiting__Failure__Handling_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Direct__Debiting__Failure__Handling_decoder(OCTETSTRING& input_stream, DCC__NONE__Direct__Debiting__Failure__Handling& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Direct_Debiting_Failure_Handling' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__Direct__Debiting__Failure__Handling_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__TWAN__User__Location__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__TWAN__User__Location__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 MIPv4__NONE__MIP__HA__to__FA__MSA_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__HA__to__FA__MSA_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Reporting__Reason_encoder(const DCA__3GPP__Reporting__Reason& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Reporting_Reason' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Reporting__Reason_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Reporting__Reason_decoder(OCTETSTRING& input_stream, DCA__3GPP__Reporting__Reason& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Reporting_Reason' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Reporting__Reason_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void RX__3GPP__Media__Component__Description_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Media__Component__Description_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__CSG__Information__Reporting_encoder(const PCC__3GPP__CSG__Information__Reporting& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_CSG_Information_Reporting' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__CSG__Information__Reporting_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__CSG__Information__Reporting_decoder(OCTETSTRING& input_stream, PCC__3GPP__CSG__Information__Reporting& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_CSG_Information_Reporting' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__CSG__Information__Reporting_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void S6__3GPP__Location__Information__Configuration_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Location__Information__Configuration_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Bearer__Usage_encoder(const PCC__3GPP__Bearer__Usage& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Bearer_Usage' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Bearer__Usage_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Bearer__Usage_decoder(OCTETSTRING& input_stream, PCC__3GPP__Bearer__Usage& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Bearer_Usage' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Bearer__Usage_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void OCTET4_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(OCTET4_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER OCTET4_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(OCTET4_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void IPFilterRule_encoder(const CHARSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `charstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CHARSTRING_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER IPFilterRule_decoder(OCTETSTRING& input_stream, CHARSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `charstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CHARSTRING_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__Requested__Service__Unit_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Requested__Service__Unit_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__TDF__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__TDF__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Traffic__Data__Volumes_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Traffic__Data__Volumes_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Requested__EUTRAN__Authentication__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Requested__EUTRAN__Authentication__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Unit__Cost_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Unit__Cost_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__SIP__Digest__Authenticate_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__SIP__Digest__Authenticate_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Used__Service__Unit_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Used__Service__Unit_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__TWAN__Access__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__TWAN__Access__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Status__AS__Code_encoder(const DCA__3GPP__Status__AS__Code& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Status_AS_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Status__AS__Code_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Status__AS__Code_decoder(OCTETSTRING& input_stream, DCA__3GPP__Status__AS__Code& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Status_AS_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Status__AS__Code_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__LCS__Client__Type_encoder(const DCA__3GPP__LCS__Client__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_LCS_Client_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__LCS__Client__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__LCS__Client__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__LCS__Client__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_LCS_Client_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__LCS__Client__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__PoC__Session__Initiation__Type_encoder(const DCA__3GPP__PoC__Session__Initiation__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_Session_Initiation_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__PoC__Session__Initiation__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PoC__Session__Initiation__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__PoC__Session__Initiation__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_Session_Initiation_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__PoC__Session__Initiation__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Access__Network__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Access__Network__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Monitoring__Event__Report_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Monitoring__Event__Report_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Conditional__Policy__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Conditional__Policy__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__ProSe__Event__Type_encoder(const DCA__3GPP__ProSe__Event__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_ProSe_Event_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__ProSe__Event__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__ProSe__Event__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__ProSe__Event__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_ProSe_Event_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__ProSe__Event__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Network__Request__Support_encoder(const PCC__3GPP__Network__Request__Support& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Network_Request_Support' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Network__Request__Support_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Network__Request__Support_decoder(OCTETSTRING& input_stream, PCC__3GPP__Network__Request__Support& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Network_Request_Support' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Network__Request__Support_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__SIPTO__Permission_encoder(const AAA__3GPP__SIPTO__Permission& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_SIPTO_Permission' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__SIPTO__Permission_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__SIPTO__Permission_decoder(OCTETSTRING& input_stream, AAA__3GPP__SIPTO__Permission& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_SIPTO_Permission' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__SIPTO__Permission_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__IMS__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__IMS__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Routing__Rule__Remove_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Routing__Rule__Remove_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Coverage__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Coverage__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__User__Authorization__Type_encoder(const CxDx__3GPP__User__Authorization__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_User_Authorization_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CxDx__3GPP__User__Authorization__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__User__Authorization__Type_decoder(OCTETSTRING& input_stream, CxDx__3GPP__User__Authorization__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_User_Authorization_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CxDx__3GPP__User__Authorization__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__PLMN__Client_encoder(const AAA__3GPP__PLMN__Client& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_PLMN_Client' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__PLMN__Client_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__PLMN__Client_decoder(OCTETSTRING& input_stream, AAA__3GPP__PLMN__Client& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_PLMN_Client' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__PLMN__Client_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__User__CSG__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__User__CSG__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__IP__Realm__Default__Indication_encoder(const DCA__3GPP__IP__Realm__Default__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_IP_Realm_Default_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__IP__Realm__Default__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__IP__Realm__Default__Indication_decoder(OCTETSTRING& input_stream, DCA__3GPP__IP__Realm__Default__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_IP_Realm_Default_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__IP__Realm__Default__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv4__NONE__MIP__MN__to__FA__MSA_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__MN__to__FA__MSA_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__SGSN__User__State_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__SGSN__User__State_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__APN__Rate__Control_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__APN__Rate__Control_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Relationship__Mode_encoder(const DCA__3GPP__Relationship__Mode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Relationship_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Relationship__Mode_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Relationship__Mode_decoder(OCTETSTRING& input_stream, DCA__3GPP__Relationship__Mode& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Relationship_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Relationship__Mode_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__Redirect__Address__Type_encoder(const DCC__NONE__Redirect__Address__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Redirect_Address_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__Redirect__Address__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Redirect__Address__Type_decoder(OCTETSTRING& input_stream, DCC__NONE__Redirect__Address__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Redirect_Address_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__Redirect__Address__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv6__NONE__MIP__MN__HA__MSA_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv6__NONE__MIP__MN__HA__MSA_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Originator_encoder(const DCA__3GPP__Originator& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Originator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Originator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Originator_decoder(OCTETSTRING& input_stream, DCA__3GPP__Originator& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Originator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Originator_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__User__Equipment__Info__Type_encoder(const DCC__NONE__User__Equipment__Info__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_User_Equipment_Info_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__User__Equipment__Info__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__User__Equipment__Info__Type_decoder(OCTETSTRING& input_stream, DCC__NONE__User__Equipment__Info__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_User_Equipment_Info_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__User__Equipment__Info__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Resource__Allocation__Notification_encoder(const PCC__3GPP__Resource__Allocation__Notification& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Resource_Allocation_Notification' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Resource__Allocation__Notification_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Resource__Allocation__Notification_decoder(OCTETSTRING& input_stream, PCC__3GPP__Resource__Allocation__Notification& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Resource_Allocation_Notification' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Resource__Allocation__Notification_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Basic__Service__Code_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Basic__Service__Code_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Role__Of__Node_encoder(const DCA__3GPP__Role__Of__Node& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Role_Of_Node' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Role__Of__Node_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Role__Of__Node_decoder(OCTETSTRING& input_stream, DCA__3GPP__Role__Of__Node& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Role_Of_Node' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Role__Of__Node_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Default__Bearer__Indication_encoder(const PCC__3GPP__Default__Bearer__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Default_Bearer_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Default__Bearer__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Default__Bearer__Indication_decoder(OCTETSTRING& input_stream, PCC__3GPP__Default__Bearer__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Default_Bearer_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Default__Bearer__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__ProSe__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__ProSe__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__VPLMN__LIPA__Allowed_encoder(const AAA__3GPP__VPLMN__LIPA__Allowed& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_VPLMN_LIPA_Allowed' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__VPLMN__LIPA__Allowed_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__VPLMN__LIPA__Allowed_decoder(OCTETSTRING& input_stream, AAA__3GPP__VPLMN__LIPA__Allowed& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_VPLMN_LIPA_Allowed' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__VPLMN__LIPA__Allowed_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Mute__Notification_encoder(const PCC__3GPP__Mute__Notification& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Mute_Notification' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Mute__Notification_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Mute__Notification_decoder(OCTETSTRING& input_stream, PCC__3GPP__Mute__Notification& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Mute_Notification' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Mute__Notification_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv6__NONE__QoS__Resources_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv6__NONE__QoS__Resources_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Logging__Duration_encoder(const AAA__3GPP__Logging__Duration& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Logging_Duration' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Logging__Duration_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Logging__Duration_decoder(OCTETSTRING& input_stream, AAA__3GPP__Logging__Duration& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Logging_Duration' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Logging__Duration_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__Associated__Registered__Identities_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Associated__Registered__Identities_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Destination__Interface_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Destination__Interface_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__IMS__Emergency__Indicator_encoder(const DCA__3GPP__IMS__Emergency__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 `@DIAMETER_Types.DCA_3GPP_IMS_Emergency_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__IMS__Emergency__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__IMS__Emergency__Indicator_decoder(OCTETSTRING& input_stream, DCA__3GPP__IMS__Emergency__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 `@DIAMETER_Types.DCA_3GPP_IMS_Emergency_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__IMS__Emergency__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 DCA__3GPP__AoC__Cost__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__AoC__Cost__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Teleservice__List_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Teleservice__List_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__UTRAN__Vector_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__UTRAN__Vector_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Non__3GPP__IP__Access__APN_encoder(const AAA__3GPP__Non__3GPP__IP__Access__APN& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Non_3GPP_IP_Access_APN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Non__3GPP__IP__Access__APN_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Non__3GPP__IP__Access__APN_decoder(OCTETSTRING& input_stream, AAA__3GPP__Non__3GPP__IP__Access__APN& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Non_3GPP_IP_Access_APN' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Non__3GPP__IP__Access__APN_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Monitoring__Event__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Monitoring__Event__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__NIDD__Authorization__Request_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__NIDD__Authorization__Request_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 INT32_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(INT32_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER INT32_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(INT32_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__QoS__Rule__Install_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__QoS__Rule__Install_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Service__Specific__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Service__Specific__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 RX__3GPP__Flow__Usage_encoder(const RX__3GPP__Flow__Usage& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Flow_Usage' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__Flow__Usage_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Flow__Usage_decoder(OCTETSTRING& input_stream, RX__3GPP__Flow__Usage& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Flow_Usage' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__Flow__Usage_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__QoS__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__QoS__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DNAS__NONE__Tunneling_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__Tunneling_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__eDRX__Cycle__Length_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__eDRX__Cycle__Length_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Group__Monitoring__Event__Report__Item_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Group__Monitoring__Event__Report__Item_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Rule__Failure__Code_encoder(const PCC__3GPP__Rule__Failure__Code& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Rule_Failure_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Rule__Failure__Code_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Rule__Failure__Code_decoder(OCTETSTRING& input_stream, PCC__3GPP__Rule__Failure__Code& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Rule_Failure_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Rule__Failure__Code_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Usage__Monitoring__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Usage__Monitoring__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Measurement__Period__LTE_encoder(const AAA__3GPP__Measurement__Period__LTE& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Measurement_Period_LTE' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Measurement__Period__LTE_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Measurement__Period__LTE_decoder(OCTETSTRING& input_stream, AAA__3GPP__Measurement__Period__LTE& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Measurement_Period_LTE' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Measurement__Period__LTE_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__Session__Priority_encoder(const CxDx__3GPP__Session__Priority& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Session_Priority' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CxDx__3GPP__Session__Priority_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Session__Priority_decoder(OCTETSTRING& input_stream, CxDx__3GPP__Session__Priority& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Session_Priority' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CxDx__3GPP__Session__Priority_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Recipient__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Recipient__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__AoC__Format_encoder(const DCA__3GPP__AoC__Format& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_AoC_Format' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__AoC__Format_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__AoC__Format_decoder(OCTETSTRING& input_stream, DCA__3GPP__AoC__Format& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_AoC_Format' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__AoC__Format_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__Deregistration__Reason_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Deregistration__Reason_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Interface__Type_encoder(const DCA__3GPP__Interface__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Interface_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Interface__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Interface__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__Interface__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Interface_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Interface__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv4__NONE__MIP__Originating__Foreign__AAA_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__Originating__Foreign__AAA_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__DRM__Content_encoder(const DCA__3GPP__DRM__Content& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_DRM_Content' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__DRM__Content_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__DRM__Content_decoder(OCTETSTRING& input_stream, DCA__3GPP__DRM__Content& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_DRM_Content' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__DRM__Content_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__Multiple__Services__Indicator_encoder(const DCC__NONE__Multiple__Services__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 `@DIAMETER_Types.DCC_NONE_Multiple_Services_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__Multiple__Services__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Multiple__Services__Indicator_decoder(OCTETSTRING& input_stream, DCC__NONE__Multiple__Services__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 `@DIAMETER_Types.DCC_NONE_Multiple_Services_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__Multiple__Services__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 DCA__3GPP__Early__Media__Description_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Early__Media__Description_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Related__Change__Condition__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Related__Change__Condition__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DNAS__NONE__Framed__Protocol_encoder(const DNAS__NONE__Framed__Protocol& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Framed_Protocol' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DNAS__NONE__Framed__Protocol_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__Framed__Protocol_decoder(OCTETSTRING& input_stream, DNAS__NONE__Framed__Protocol& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Framed_Protocol' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DNAS__NONE__Framed__Protocol_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void S6__3GPP__Service__ID_encoder(const S6__3GPP__Service__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 `@DIAMETER_Types.S6_3GPP_Service_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(S6__3GPP__Service__ID_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Service__ID_decoder(OCTETSTRING& input_stream, S6__3GPP__Service__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 `@DIAMETER_Types.S6_3GPP_Service_ID' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(S6__3GPP__Service__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 DCA__3GPP__LCS__Format__Indicator_encoder(const DCA__3GPP__LCS__Format__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 `@DIAMETER_Types.DCA_3GPP_LCS_Format_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__LCS__Format__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__LCS__Format__Indicator_decoder(OCTETSTRING& input_stream, DCA__3GPP__LCS__Format__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 `@DIAMETER_Types.DCA_3GPP_LCS_Format_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__LCS__Format__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 RX__3GPP__Abort__Cause_encoder(const RX__3GPP__Abort__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 `@DIAMETER_Types.RX_3GPP_Abort_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__Abort__Cause_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Abort__Cause_decoder(OCTETSTRING& input_stream, RX__3GPP__Abort__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 `@DIAMETER_Types.RX_3GPP_Abort_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__Abort__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 RX__3GPP__Required__Access__Info_encoder(const RX__3GPP__Required__Access__Info& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Required_Access_Info' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__Required__Access__Info_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Required__Access__Info_decoder(OCTETSTRING& input_stream, RX__3GPP__Required__Access__Info& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Required_Access_Info' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__Required__Access__Info_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__QoS__Rule__Report_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__QoS__Rule__Report_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__Server__Capabilities_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Server__Capabilities_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Area__Scope_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Area__Scope_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__SGW__Change_encoder(const DCA__3GPP__SGW__Change& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_SGW_Change' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__SGW__Change_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SGW__Change_decoder(OCTETSTRING& input_stream, DCA__3GPP__SGW__Change& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_SGW_Change' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__SGW__Change_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__SCSCF__Restoration__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__SCSCF__Restoration__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__AoC__Subscription__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__AoC__Subscription__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DiameterURI_encoder(const CHARSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `charstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CHARSTRING_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DiameterURI_decoder(OCTETSTRING& input_stream, CHARSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `charstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CHARSTRING_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Notification__To__UE__User_encoder(const AAA__3GPP__Notification__To__UE__User& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Notification_To_UE_User' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Notification__To__UE__User_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Notification__To__UE__User_decoder(OCTETSTRING& input_stream, AAA__3GPP__Notification__To__UE__User& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Notification_To_UE_User' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Notification__To__UE__User_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Homogeneous__Support__of__IMS__Voice__Over__PS__Sessions_encoder(const AAA__3GPP__Homogeneous__Support__of__IMS__Voice__Over__PS__Sessions& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Homogeneous_Support_of_IMS_Voice_Over_PS_Sessions' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Homogeneous__Support__of__IMS__Voice__Over__PS__Sessions_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Homogeneous__Support__of__IMS__Voice__Over__PS__Sessions_decoder(OCTETSTRING& input_stream, AAA__3GPP__Homogeneous__Support__of__IMS__Voice__Over__PS__Sessions& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Homogeneous_Support_of_IMS_Voice_Over_PS_Sessions' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Homogeneous__Support__of__IMS__Voice__Over__PS__Sessions_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Participant__Group_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Participant__Group_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Play__Alternative_encoder(const DCA__3GPP__Play__Alternative& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Play_Alternative' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Play__Alternative_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Play__Alternative_decoder(OCTETSTRING& input_stream, DCA__3GPP__Play__Alternative& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Play_Alternative' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Play__Alternative_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__MBMS__User__Service__Type_encoder(const DCA__3GPP__MBMS__User__Service__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_MBMS_User_Service_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__MBMS__User__Service__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__MBMS__User__Service__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__MBMS__User__Service__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_MBMS_User_Service_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__MBMS__User__Service__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void S6__3GPP__Monitoring__Event__Config__Status_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Monitoring__Event__Config__Status_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__AF__Correlation__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__AF__Correlation__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Cost__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Cost__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Service__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Service__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Monitoring__Event__Configuration_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Monitoring__Event__Configuration_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Offline_encoder(const PCC__3GPP__Offline& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Offline' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Offline_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Offline_decoder(OCTETSTRING& input_stream, PCC__3GPP__Offline& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Offline' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Offline_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__ADC__Rule__Definition_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__ADC__Rule__Definition_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DNAS__NONE__Login__Service_encoder(const DNAS__NONE__Login__Service& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Login_Service' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DNAS__NONE__Login__Service_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__Login__Service_decoder(OCTETSTRING& input_stream, DNAS__NONE__Login__Service& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Login_Service' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DNAS__NONE__Login__Service_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void S6__3GPP__Allowed__PLMN__List_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Allowed__PLMN__List_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Bearer__Control__Mode_encoder(const PCC__3GPP__Bearer__Control__Mode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Bearer_Control_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Bearer__Control__Mode_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Bearer__Control__Mode_decoder(OCTETSTRING& input_stream, PCC__3GPP__Bearer__Control__Mode& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Bearer_Control_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Bearer__Control__Mode_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Active__APN_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Active__APN_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__SMS__Register__Request_encoder(const AAA__3GPP__SMS__Register__Request& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_SMS_Register_Request' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__SMS__Register__Request_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__SMS__Register__Request_decoder(OCTETSTRING& input_stream, AAA__3GPP__SMS__Register__Request& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_SMS_Register_Request' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__SMS__Register__Request_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__Subscription__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Subscription__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__APN__Configuration_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__APN__Configuration_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Subscriber__Role_encoder(const DCA__3GPP__Subscriber__Role& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Subscriber_Role' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Subscriber__Role_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Subscriber__Role_decoder(OCTETSTRING& input_stream, DCA__3GPP__Subscriber__Role& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Subscriber_Role' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Subscriber__Role_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__GMLC__Restriction_encoder(const AAA__3GPP__GMLC__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 `@DIAMETER_Types.AAA_3GPP_GMLC_Restriction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__GMLC__Restriction_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__GMLC__Restriction_decoder(OCTETSTRING& input_stream, AAA__3GPP__GMLC__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 `@DIAMETER_Types.AAA_3GPP_GMLC_Restriction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__GMLC__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 DCC__NONE__CC__Session__Failover_encoder(const DCC__NONE__CC__Session__Failover& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_CC_Session_Failover' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__CC__Session__Failover_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__CC__Session__Failover_decoder(OCTETSTRING& input_stream, DCC__NONE__CC__Session__Failover& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_CC_Session_Failover' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__CC__Session__Failover_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Enhanced__Diagnostics_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Enhanced__Diagnostics_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__CSG__Membership__Indication_encoder(const DCA__3GPP__CSG__Membership__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_CSG_Membership_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__CSG__Membership__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__CSG__Membership__Indication_decoder(OCTETSTRING& input_stream, DCA__3GPP__CSG__Membership__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_CSG_Membership_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__CSG__Membership__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Message__Class_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Message__Class_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Trigger_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Trigger_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Called__Identity__Change_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Called__Identity__Change_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__PoC__Server__Role_encoder(const DCA__3GPP__PoC__Server__Role& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_Server_Role' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__PoC__Server__Role_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PoC__Server__Role_decoder(OCTETSTRING& input_stream, DCA__3GPP__PoC__Server__Role& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_Server_Role' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__PoC__Server__Role_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Forwarding__Pending_encoder(const DCA__3GPP__Forwarding__Pending& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Forwarding_Pending' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Forwarding__Pending_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Forwarding__Pending_decoder(OCTETSTRING& input_stream, DCA__3GPP__Forwarding__Pending& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Forwarding_Pending' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Forwarding__Pending_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__Credit__Control__Failure__Handling_encoder(const DCC__NONE__Credit__Control__Failure__Handling& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Credit_Control_Failure_Handling' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__Credit__Control__Failure__Handling_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Credit__Control__Failure__Handling_decoder(OCTETSTRING& input_stream, DCC__NONE__Credit__Control__Failure__Handling& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Credit_Control_Failure_Handling' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__Credit__Control__Failure__Handling_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv6__NONE__MIP6__Agent__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv6__NONE__MIP6__Agent__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Service__Result_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Service__Result_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Reporting__Level_encoder(const PCC__3GPP__Reporting__Level& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Reporting_Level' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Reporting__Level_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Reporting__Level_decoder(OCTETSTRING& input_stream, PCC__3GPP__Reporting__Level& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Reporting_Level' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Reporting__Level_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__MME__Location__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__MME__Location__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Pre__emption__Capability_encoder(const PCC__3GPP__Pre__emption__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 `@DIAMETER_Types.PCC_3GPP_Pre_emption_Capability' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Pre__emption__Capability_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Pre__emption__Capability_decoder(OCTETSTRING& input_stream, PCC__3GPP__Pre__emption__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 `@DIAMETER_Types.PCC_3GPP_Pre_emption_Capability' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Pre__emption__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 AAA__3GPP__Subscribed__VSRVCC_encoder(const AAA__3GPP__Subscribed__VSRVCC& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Subscribed_VSRVCC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Subscribed__VSRVCC_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Subscribed__VSRVCC_decoder(OCTETSTRING& input_stream, AAA__3GPP__Subscribed__VSRVCC& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Subscribed_VSRVCC' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Subscribed__VSRVCC_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Address__Type_encoder(const DCA__3GPP__Address__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Address_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Address__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Address__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__Address__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Address_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Address__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Application__Detection__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Application__Detection__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Emergency__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Emergency__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Remaining__Balance_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Remaining__Balance_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Next__Tariff_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Next__Tariff_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Requested__Action_encoder(const DCC__NONE__Requested__Action& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Requested_Action' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__Requested__Action_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Requested__Action_decoder(OCTETSTRING& input_stream, DCC__NONE__Requested__Action& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Requested_Action' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__Requested__Action_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Alert__Reason_encoder(const AAA__3GPP__Alert__Reason& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Alert_Reason' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Alert__Reason_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Alert__Reason_decoder(OCTETSTRING& input_stream, AAA__3GPP__Alert__Reason& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Alert_Reason' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Alert__Reason_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Recipient__Address_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Recipient__Address_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__SCS__AS__Address_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SCS__AS__Address_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__MO__LR_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__MO__LR_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__PoC__User__Role_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PoC__User__Role_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Non__3GPP__IP__Access_encoder(const AAA__3GPP__Non__3GPP__IP__Access& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Non_3GPP_IP_Access' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Non__3GPP__IP__Access_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Non__3GPP__IP__Access_decoder(OCTETSTRING& input_stream, AAA__3GPP__Non__3GPP__IP__Access& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Non_3GPP_IP_Access' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Non__3GPP__IP__Access_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Monitoring__Event__Report__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Monitoring__Event__Report__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Adaptations_encoder(const DCA__3GPP__Adaptations& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Adaptations' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Adaptations_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Adaptations_decoder(OCTETSTRING& input_stream, DCA__3GPP__Adaptations& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Adaptations' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Adaptations_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Usage__Monitoring__Support_encoder(const PCC__3GPP__Usage__Monitoring__Support& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Usage_Monitoring_Support' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Usage__Monitoring__Support_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Usage__Monitoring__Support_decoder(OCTETSTRING& input_stream, PCC__3GPP__Usage__Monitoring__Support& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Usage_Monitoring_Support' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Usage__Monitoring__Support_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Envelope__Reporting_encoder(const DCA__3GPP__Envelope__Reporting& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Envelope_Reporting' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Envelope__Reporting_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Envelope__Reporting_decoder(OCTETSTRING& input_stream, DCA__3GPP__Envelope__Reporting& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Envelope_Reporting' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Envelope__Reporting_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Proximity__Alert__Indication_encoder(const DCA__3GPP__Proximity__Alert__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Proximity_Alert_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Proximity__Alert__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Proximity__Alert__Indication_decoder(OCTETSTRING& input_stream, DCA__3GPP__Proximity__Alert__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Proximity_Alert_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Proximity__Alert__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Trunk__Group__Id_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Trunk__Group__Id_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Default__QoS__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Default__QoS__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__NBIFOM__Support_encoder(const PCC__3GPP__NBIFOM__Support& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_NBIFOM_Support' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__NBIFOM__Support_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__NBIFOM__Support_decoder(OCTETSTRING& input_stream, PCC__3GPP__NBIFOM__Support& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_NBIFOM_Support' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__NBIFOM__Support_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Redirect__Support_encoder(const PCC__3GPP__Redirect__Support& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Redirect_Support' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Redirect__Support_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Redirect__Support_decoder(OCTETSTRING& input_stream, PCC__3GPP__Redirect__Support& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Redirect_Support' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Redirect__Support_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__IMSI__Group__Id_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__IMSI__Group__Id_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Tariff__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Tariff__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__PoC__Event__Type_encoder(const DCA__3GPP__PoC__Event__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_Event_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__PoC__Event__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PoC__Event__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__PoC__Event__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_Event_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__PoC__Event__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Trace__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Trace__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__LCS__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__LCS__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__PDN__GW__Allocation__Type_encoder(const AAA__3GPP__PDN__GW__Allocation__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_PDN_GW_Allocation_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__PDN__GW__Allocation__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__PDN__GW__Allocation__Type_decoder(OCTETSTRING& input_stream, AAA__3GPP__PDN__GW__Allocation__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_PDN_GW_Allocation_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__PDN__GW__Allocation__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Content__Class_encoder(const DCA__3GPP__Content__Class& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Content_Class' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Content__Class_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Content__Class_decoder(OCTETSTRING& input_stream, DCA__3GPP__Content__Class& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Content_Class' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Content__Class_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__TAD__Identifier_encoder(const DCA__3GPP__TAD__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 `@DIAMETER_Types.DCA_3GPP_TAD_Identifier' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__TAD__Identifier_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__TAD__Identifier_decoder(OCTETSTRING& input_stream, DCA__3GPP__TAD__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 `@DIAMETER_Types.DCA_3GPP_TAD_Identifier' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__TAD__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 DCC__NONE__Final__Unit__Action_encoder(const DCC__NONE__Final__Unit__Action& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Final_Unit_Action' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__Final__Unit__Action_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Final__Unit__Action_decoder(OCTETSTRING& input_stream, DCC__NONE__Final__Unit__Action& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Final_Unit_Action' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__Final__Unit__Action_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Service__Generic__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Service__Generic__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__ProSe__Direct__Discovery__Model_encoder(const DCA__3GPP__ProSe__Direct__Discovery__Model& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_ProSe_Direct_Discovery_Model' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__ProSe__Direct__Discovery__Model_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__ProSe__Direct__Discovery__Model_decoder(OCTETSTRING& input_stream, DCA__3GPP__ProSe__Direct__Discovery__Model& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_ProSe_Direct_Discovery_Model' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__ProSe__Direct__Discovery__Model_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__SM__Device__Trigger__Indicator_encoder(const DCA__3GPP__SM__Device__Trigger__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 `@DIAMETER_Types.DCA_3GPP_SM_Device_Trigger_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__SM__Device__Trigger__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SM__Device__Trigger__Indicator_decoder(OCTETSTRING& input_stream, DCA__3GPP__SM__Device__Trigger__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 `@DIAMETER_Types.DCA_3GPP_SM_Device_Trigger_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__SM__Device__Trigger__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 S6__3GPP__User__Identifier_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__User__Identifier_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Charging__Rule__Definition_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Charging__Rule__Definition_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__CoA__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__CoA__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Report__Amount_encoder(const AAA__3GPP__Report__Amount& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Report_Amount' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Report__Amount_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Report__Amount_decoder(OCTETSTRING& input_stream, AAA__3GPP__Report__Amount& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Report_Amount' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Report__Amount_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__User__Equipment__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__User__Equipment__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Routing__Rule__Report_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Routing__Rule__Report_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Low__Priority__Indicator_encoder(const DCA__3GPP__Low__Priority__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 `@DIAMETER_Types.DCA_3GPP_Low_Priority_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Low__Priority__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Low__Priority__Indicator_decoder(OCTETSTRING& input_stream, DCA__3GPP__Low__Priority__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 `@DIAMETER_Types.DCA_3GPP_Low_Priority_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Low__Priority__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 DCA__3GPP__Participant__Action__Type_encoder(const DCA__3GPP__Participant__Action__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Participant_Action_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Participant__Action__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Participant__Action__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__Participant__Action__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Participant_Action_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Participant__Action__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__Loose__Route__Indication_encoder(const CxDx__3GPP__Loose__Route__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Loose_Route_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CxDx__3GPP__Loose__Route__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Loose__Route__Indication_decoder(OCTETSTRING& input_stream, CxDx__3GPP__Loose__Route__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Loose_Route_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CxDx__3GPP__Loose__Route__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__MME__User__State_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__MME__User__State_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__UNI__PDU__CP__Only__Flag_encoder(const DCA__3GPP__UNI__PDU__CP__Only__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 `@DIAMETER_Types.DCA_3GPP_UNI_PDU_CP_Only_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__UNI__PDU__CP__Only__Flag_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__UNI__PDU__CP__Only__Flag_decoder(OCTETSTRING& input_stream, DCA__3GPP__UNI__PDU__CP__Only__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 `@DIAMETER_Types.DCA_3GPP_UNI_PDU_CP_Only_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__UNI__PDU__CP__Only__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 BASE__NONE__Failed__AVP_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Failed__AVP_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Location__Type_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Location__Type_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Quota__Indicator_encoder(const DCA__3GPP__Quota__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 `@DIAMETER_Types.DCA_3GPP_Quota_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Quota__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Quota__Indicator_decoder(OCTETSTRING& input_stream, DCA__3GPP__Quota__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 `@DIAMETER_Types.DCA_3GPP_Quota_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Quota__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 DCA__3GPP__Priority_encoder(const DCA__3GPP__Priority& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Priority' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Priority_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Priority_decoder(OCTETSTRING& input_stream, DCA__3GPP__Priority& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Priority' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Priority_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void S6__3GPP__NIDD__Authorization__Update_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__NIDD__Authorization__Update_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Subscription__Id__Type_encoder(const DCC__NONE__Subscription__Id__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Subscription_Id_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__Subscription__Id__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Subscription__Id__Type_decoder(OCTETSTRING& input_stream, DCC__NONE__Subscription__Id__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Subscription_Id_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__Subscription__Id__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv4__NONE__MIP__FA__to__HA__MSA_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__FA__to__HA__MSA_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Packet__Filter__Operation_encoder(const PCC__3GPP__Packet__Filter__Operation& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Packet_Filter_Operation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Packet__Filter__Operation_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Packet__Filter__Operation_decoder(OCTETSTRING& input_stream, PCC__3GPP__Packet__Filter__Operation& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Packet_Filter_Operation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Packet__Filter__Operation_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__VCS__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__VCS__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 RX__3GPP__SIP__Forking__Indication_encoder(const RX__3GPP__SIP__Forking__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_SIP_Forking_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__SIP__Forking__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__SIP__Forking__Indication_decoder(OCTETSTRING& input_stream, RX__3GPP__SIP__Forking__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_SIP_Forking_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__SIP__Forking__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__IP__CAN__Type_encoder(const PCC__3GPP__IP__CAN__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_IP_CAN_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__IP__CAN__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__IP__CAN__Type_decoder(OCTETSTRING& input_stream, PCC__3GPP__IP__CAN__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_IP_CAN_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__IP__CAN__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__SDP__Media__Component_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SDP__Media__Component_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__ProSe__Direct__Communication__Reception__Data__Container_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__ProSe__Direct__Communication__Reception__Data__Container_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Logging__Interval_encoder(const AAA__3GPP__Logging__Interval& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Logging_Interval' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Logging__Interval_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Logging__Interval_decoder(OCTETSTRING& input_stream, AAA__3GPP__Logging__Interval& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Logging_Interval' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Logging__Interval_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__PoC__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PoC__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Routing__Filter_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Routing__Filter_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__WLAN__offloadability_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__WLAN__offloadability_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Metering__Method_encoder(const PCC__3GPP__Metering__Method& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Metering_Method' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Metering__Method_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Metering__Method_decoder(OCTETSTRING& input_stream, PCC__3GPP__Metering__Method& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Metering_Method' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Metering__Method_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void BASE__NONE__Session__Server__Failover_encoder(const BASE__NONE__Session__Server__Failover& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Session_Server_Failover' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(BASE__NONE__Session__Server__Failover_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Session__Server__Failover_decoder(OCTETSTRING& input_stream, BASE__NONE__Session__Server__Failover& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Session_Server_Failover' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(BASE__NONE__Session__Server__Failover_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Accumulated__Cost_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Accumulated__Cost_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__E__UTRAN__Vector_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__E__UTRAN__Vector_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 BASE__NONE__Experimental__Result_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Experimental__Result_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Unit__Value_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Unit__Value_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__LCS__Client__Id_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__LCS__Client__Id_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 GI__3GPP__3GPP__PDP__Type_encoder(const GI__3GPP__3GPP__PDP__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.GI_3GPP_3GPP_PDP_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(GI__3GPP__3GPP__PDP__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER GI__3GPP__3GPP__PDP__Type_decoder(OCTETSTRING& input_stream, GI__3GPP__3GPP__PDP__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.GI_3GPP_3GPP_PDP_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(GI__3GPP__3GPP__PDP__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv4__NONE__MIP__Replay__Mode_encoder(const MIPv4__NONE__MIP__Replay__Mode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.MIPv4_NONE_MIP_Replay_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(MIPv4__NONE__MIP__Replay__Mode_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__Replay__Mode_decoder(OCTETSTRING& input_stream, MIPv4__NONE__MIP__Replay__Mode& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.MIPv4_NONE_MIP_Replay_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(MIPv4__NONE__MIP__Replay__Mode_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Additional__Exception__Reports_encoder(const DCA__3GPP__Additional__Exception__Reports& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Additional_Exception_Reports' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Additional__Exception__Reports_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Additional__Exception__Reports_decoder(OCTETSTRING& input_stream, DCA__3GPP__Additional__Exception__Reports& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Additional_Exception_Reports' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Additional__Exception__Reports_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Access__Transfer__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Access__Transfer__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Communication__Pattern__Set_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Communication__Pattern__Set_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__MMBox__Storage__Requested_encoder(const DCA__3GPP__MMBox__Storage__Requested& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_MMBox_Storage_Requested' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__MMBox__Storage__Requested_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__MMBox__Storage__Requested_decoder(OCTETSTRING& input_stream, DCA__3GPP__MMBox__Storage__Requested& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_MMBox_Storage_Requested' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__MMBox__Storage__Requested_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void RX__3GPP__Flow__Status_encoder(const RX__3GPP__Flow__Status& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Flow_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__Flow__Status_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Flow__Status_decoder(OCTETSTRING& input_stream, RX__3GPP__Flow__Status& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Flow_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__Flow__Status_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__CC__Unit__Type_encoder(const DCC__NONE__CC__Unit__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_CC_Unit_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__CC__Unit__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__CC__Unit__Type_decoder(OCTETSTRING& input_stream, DCC__NONE__CC__Unit__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_CC_Unit_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__CC__Unit__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void S6__3GPP__Group__Monitoring__Event__Report_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Group__Monitoring__Event__Report_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__QoS__Upgrade_encoder(const PCC__3GPP__QoS__Upgrade& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_QoS_Upgrade' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__QoS__Upgrade_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__QoS__Upgrade_decoder(OCTETSTRING& input_stream, PCC__3GPP__QoS__Upgrade& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_QoS_Upgrade' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__QoS__Upgrade_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__PS__Append__Free__Format__Data_encoder(const DCA__3GPP__PS__Append__Free__Format__Data& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PS_Append_Free_Format_Data' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__PS__Append__Free__Format__Data_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PS__Append__Free__Format__Data_decoder(OCTETSTRING& input_stream, DCA__3GPP__PS__Append__Free__Format__Data& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PS_Append_Free_Format_Data' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__PS__Append__Free__Format__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 PCC__3GPP__AN__GW__Status_encoder(const PCC__3GPP__AN__GW__Status& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_AN_GW_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__AN__GW__Status_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__AN__GW__Status_decoder(OCTETSTRING& input_stream, PCC__3GPP__AN__GW__Status& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_AN_GW_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__AN__GW__Status_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Measurement__Period__UMTS_encoder(const AAA__3GPP__Measurement__Period__UMTS& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Measurement_Period_UMTS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Measurement__Period__UMTS_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Measurement__Period__UMTS_decoder(OCTETSTRING& input_stream, AAA__3GPP__Measurement__Period__UMTS& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Measurement_Period_UMTS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Measurement__Period__UMTS_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Media__Initiator__Flag_encoder(const DCA__3GPP__Media__Initiator__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 `@DIAMETER_Types.DCA_3GPP_Media_Initiator_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Media__Initiator__Flag_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Media__Initiator__Flag_decoder(OCTETSTRING& input_stream, DCA__3GPP__Media__Initiator__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 `@DIAMETER_Types.DCA_3GPP_Media_Initiator_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Media__Initiator__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 PCC__3GPP__3GPP__PS__Data__Off__Status_encoder(const PCC__3GPP__3GPP__PS__Data__Off__Status& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_3GPP_PS_Data_Off_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__3GPP__PS__Data__Off__Status_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__3GPP__PS__Data__Off__Status_decoder(OCTETSTRING& input_stream, PCC__3GPP__3GPP__PS__Data__Off__Status& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_3GPP_PS_Data_Off_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__3GPP__PS__Data__Off__Status_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Routing__Rule__Install_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Routing__Rule__Install_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Service__Data__Container_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Service__Data__Container_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__Server__Assignment__Type_encoder(const CxDx__3GPP__Server__Assignment__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Server_Assignment_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CxDx__3GPP__Server__Assignment__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Server__Assignment__Type_decoder(OCTETSTRING& input_stream, CxDx__3GPP__Server__Assignment__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Server_Assignment_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CxDx__3GPP__Server__Assignment__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__IP__CAN__Session__Charging__Scope_encoder(const PCC__3GPP__IP__CAN__Session__Charging__Scope& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_IP_CAN_Session_Charging_Scope' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__IP__CAN__Session__Charging__Scope_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__IP__CAN__Session__Charging__Scope_decoder(OCTETSTRING& input_stream, PCC__3GPP__IP__CAN__Session__Charging__Scope& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_IP_CAN_Session_Charging_Scope' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__IP__CAN__Session__Charging__Scope_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DNAS__NONE__Framed__Routing_encoder(const DNAS__NONE__Framed__Routing& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Framed_Routing' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DNAS__NONE__Framed__Routing_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__Framed__Routing_decoder(OCTETSTRING& input_stream, DNAS__NONE__Framed__Routing& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Framed_Routing' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DNAS__NONE__Framed__Routing_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Current__Tariff_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Current__Tariff_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Time__Quota__Type_encoder(const DCA__3GPP__Time__Quota__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Time_Quota_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Time__Quota__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Time__Quota__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__Time__Quota__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Time_Quota_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Time__Quota__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Trace__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Trace__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__PDP__Context_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__PDP__Context_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__CC__Money_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__CC__Money_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 BASE__NONE__Proxy__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Proxy__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 RX__3GPP__Priority__Sharing__Indicator_encoder(const RX__3GPP__Priority__Sharing__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 `@DIAMETER_Types.RX_3GPP_Priority_Sharing_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__Priority__Sharing__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Priority__Sharing__Indicator_decoder(OCTETSTRING& input_stream, RX__3GPP__Priority__Sharing__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 `@DIAMETER_Types.RX_3GPP_Priority_Sharing_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__Priority__Sharing__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 DCA__3GPP__Trigger__Type_encoder(const DCA__3GPP__Trigger__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Trigger_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Trigger__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Trigger__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__Trigger__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Trigger_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Trigger__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void S6__3GPP__Scheduled__Communication__Time_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Scheduled__Communication__Time_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Role__Of__ProSe__Function_encoder(const DCA__3GPP__Role__Of__ProSe__Function& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Role_Of_ProSe_Function' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Role__Of__ProSe__Function_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Role__Of__ProSe__Function_decoder(OCTETSTRING& input_stream, DCA__3GPP__Role__Of__ProSe__Function& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Role_Of_ProSe_Function' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Role__Of__ProSe__Function_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__PCC__Rule__Status_encoder(const PCC__3GPP__PCC__Rule__Status& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_PCC_Rule_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__PCC__Rule__Status_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__PCC__Rule__Status_decoder(OCTETSTRING& input_stream, PCC__3GPP__PCC__Rule__Status& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_PCC_Rule_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__PCC__Rule__Status_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__MBSFN__Area_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__MBSFN__Area_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__APN__Validity__Time_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__APN__Validity__Time_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Allocation__Retention__Priority_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Allocation__Retention__Priority_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Check__Balance__Result_encoder(const DCC__NONE__Check__Balance__Result& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Check_Balance_Result' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__Check__Balance__Result_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Check__Balance__Result_decoder(OCTETSTRING& input_stream, DCC__NONE__Check__Balance__Result& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Check_Balance_Result' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__Check__Balance__Result_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Job__Type_encoder(const AAA__3GPP__Job__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Job_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Job__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Job__Type_decoder(OCTETSTRING& input_stream, AAA__3GPP__Job__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Job_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Job__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__AoC__Service__Type_encoder(const DCA__3GPP__AoC__Service__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_AoC_Service_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__AoC__Service__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__AoC__Service__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__AoC__Service__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_AoC_Service_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__AoC__Service__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DNAS__NONE__Origin__AAA__Protocol_encoder(const DNAS__NONE__Origin__AAA__Protocol& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Origin_AAA_Protocol' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DNAS__NONE__Origin__AAA__Protocol_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__Origin__AAA__Protocol_decoder(OCTETSTRING& input_stream, DNAS__NONE__Origin__AAA__Protocol& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Origin_AAA_Protocol' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DNAS__NONE__Origin__AAA__Protocol_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__Charging__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Charging__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Originator__Interface_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Originator__Interface_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__IMS__Voice__Over__PS__Sessions__Supported_encoder(const AAA__3GPP__IMS__Voice__Over__PS__Sessions__Supported& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_IMS_Voice_Over_PS_Sessions_Supported' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__IMS__Voice__Over__PS__Sessions__Supported_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__IMS__Voice__Over__PS__Sessions__Supported_decoder(OCTETSTRING& input_stream, AAA__3GPP__IMS__Voice__Over__PS__Sessions__Supported& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_IMS_Voice_Over_PS_Sessions_Supported' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__IMS__Voice__Over__PS__Sessions__Supported_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Roaming__Restricted__Due__To__Unsupported__Feature_encoder(const AAA__3GPP__Roaming__Restricted__Due__To__Unsupported__Feature& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Roaming_Restricted_Due_To_Unsupported_Feature' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Roaming__Restricted__Due__To__Unsupported__Feature_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Roaming__Restricted__Due__To__Unsupported__Feature_decoder(OCTETSTRING& input_stream, AAA__3GPP__Roaming__Restricted__Due__To__Unsupported__Feature& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Roaming_Restricted_Due_To_Unsupported_Feature' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Roaming__Restricted__Due__To__Unsupported__Feature_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__File__Repair__Supported_encoder(const DCA__3GPP__File__Repair__Supported& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_File_Repair_Supported' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__File__Repair__Supported_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__File__Repair__Supported_decoder(OCTETSTRING& input_stream, DCA__3GPP__File__Repair__Supported& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_File_Repair_Supported' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__File__Repair__Supported_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__WLAN__Identifier_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__WLAN__Identifier_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__NIDD__Submission_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__NIDD__Submission_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__T4__Parameters_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__T4__Parameters_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__AESE__Error__Report_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__AESE__Error__Report_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Event__Type_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Event__Type_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__ADC__Rule__Remove_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__ADC__Rule__Remove_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__ProSe__Direct__Communication__Transmission__Data__Container_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__ProSe__Direct__Communication__Transmission__Data__Container_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Restricted__PLMN__List_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Restricted__PLMN__List_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Access__Network__Charging__Identifier__Gx_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Access__Network__Charging__Identifier__Gx_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Flow__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Flow__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__PS__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PS__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Charging__Correlation__Indicator_encoder(const PCC__3GPP__Charging__Correlation__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 `@DIAMETER_Types.PCC_3GPP_Charging_Correlation_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Charging__Correlation__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Charging__Correlation__Indicator_decoder(OCTETSTRING& input_stream, PCC__3GPP__Charging__Correlation__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 `@DIAMETER_Types.PCC_3GPP_Charging_Correlation_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Charging__Correlation__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 DCC__NONE__Credit__Control_encoder(const DCC__NONE__Credit__Control& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Credit_Control' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__Credit__Control_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Credit__Control_decoder(OCTETSTRING& input_stream, DCC__NONE__Credit__Control& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Credit_Control' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__Credit__Control_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Report__Interval_encoder(const AAA__3GPP__Report__Interval& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Report_Interval' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Report__Interval_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Report__Interval_decoder(OCTETSTRING& input_stream, AAA__3GPP__Report__Interval& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Report_Interval' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Report__Interval_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Dynamic__Address__Flag__Extension_encoder(const DCA__3GPP__Dynamic__Address__Flag__Extension& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Dynamic_Address_Flag_Extension' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Dynamic__Address__Flag__Extension_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Dynamic__Address__Flag__Extension_decoder(OCTETSTRING& input_stream, DCA__3GPP__Dynamic__Address__Flag__Extension& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Dynamic_Address_Flag_Extension' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Dynamic__Address__Flag__Extension_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void BASE__NONE__Redirect__Host__Usage_encoder(const BASE__NONE__Redirect__Host__Usage& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Redirect_Host_Usage' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(BASE__NONE__Redirect__Host__Usage_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Redirect__Host__Usage_decoder(OCTETSTRING& input_stream, BASE__NONE__Redirect__Host__Usage& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.BASE_NONE_Redirect_Host_Usage' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(BASE__NONE__Redirect__Host__Usage_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__CSG__Access__Mode_encoder(const DCA__3GPP__CSG__Access__Mode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_CSG_Access_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__CSG__Access__Mode_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__CSG__Access__Mode_decoder(OCTETSTRING& input_stream, DCA__3GPP__CSG__Access__Mode& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_CSG_Access_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__CSG__Access__Mode_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Equipment__Status_encoder(const AAA__3GPP__Equipment__Status& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Equipment_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Equipment__Status_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Equipment__Status_decoder(OCTETSTRING& input_stream, AAA__3GPP__Equipment__Status& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Equipment_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Equipment__Status_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Supplementary__Service_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Supplementary__Service_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__EPS__Location__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__EPS__Location__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__SGi__PtP__Tunnelling__Method_encoder(const DCA__3GPP__SGi__PtP__Tunnelling__Method& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_SGi_PtP_Tunnelling_Method' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__SGi__PtP__Tunnelling__Method_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SGi__PtP__Tunnelling__Method_decoder(OCTETSTRING& input_stream, DCA__3GPP__SGi__PtP__Tunnelling__Method& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_SGi_PtP_Tunnelling_Method' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__SGi__PtP__Tunnelling__Method_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__NNI__Type_encoder(const DCA__3GPP__NNI__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_NNI_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__NNI__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__NNI__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__NNI__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_NNI_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__NNI__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void RX__3GPP__Service__Info__Status_encoder(const RX__3GPP__Service__Info__Status& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Service_Info_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__Service__Info__Status_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Service__Info__Status_decoder(OCTETSTRING& input_stream, RX__3GPP__Service__Info__Status& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Service_Info_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__Service__Info__Status_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__User__Participating__Type_encoder(const DCA__3GPP__User__Participating__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_User_Participating_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__User__Participating__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__User__Participating__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__User__Participating__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_User_Participating_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__User__Participating__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void RX__3GPP__Sponsoring__Action_encoder(const RX__3GPP__Sponsoring__Action& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Sponsoring_Action' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__Sponsoring__Action_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Sponsoring__Action_decoder(OCTETSTRING& input_stream, RX__3GPP__Sponsoring__Action& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Sponsoring_Action' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__Sponsoring__Action_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Node__Functionality_encoder(const DCA__3GPP__Node__Functionality& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Node_Functionality' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Node__Functionality_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Node__Functionality_decoder(OCTETSTRING& input_stream, DCA__3GPP__Node__Functionality& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Node_Functionality' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Node__Functionality_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Packet__Filter__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Packet__Filter__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Daylight__Saving__Time_encoder(const AAA__3GPP__Daylight__Saving__Time& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Daylight_Saving_Time' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Daylight__Saving__Time_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Daylight__Saving__Time_decoder(OCTETSTRING& input_stream, AAA__3GPP__Daylight__Saving__Time& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Daylight_Saving_Time' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Daylight__Saving__Time_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Address__Domain_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Address__Domain_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Removal__Of__Access_encoder(const PCC__3GPP__Removal__Of__Access& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Removal_Of_Access' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Removal__Of__Access_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Removal__Of__Access_decoder(OCTETSTRING& input_stream, PCC__3GPP__Removal__Of__Access& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Removal_Of_Access' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Removal__Of__Access_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__ADC__Rule__Report_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__ADC__Rule__Report_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Preferred__Data__Mode_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Preferred__Data__Mode_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__ProSe__Functionality_encoder(const DCA__3GPP__ProSe__Functionality& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_ProSe_Functionality' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__ProSe__Functionality_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__ProSe__Functionality_decoder(OCTETSTRING& input_stream, DCA__3GPP__ProSe__Functionality& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_ProSe_Functionality' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__ProSe__Functionality_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Low__Balance__Indication_encoder(const DCA__3GPP__Low__Balance__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Low_Balance_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Low__Balance__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Low__Balance__Indication_decoder(OCTETSTRING& input_stream, DCA__3GPP__Low__Balance__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Low_Balance_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Low__Balance__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__UE__SRVCC__Capability_encoder(const AAA__3GPP__UE__SRVCC__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 `@DIAMETER_Types.AAA_3GPP_UE_SRVCC_Capability' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__UE__SRVCC__Capability_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__UE__SRVCC__Capability_decoder(OCTETSTRING& input_stream, AAA__3GPP__UE__SRVCC__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 `@DIAMETER_Types.AAA_3GPP_UE_SRVCC_Capability' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__UE__SRVCC__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 DCA__3GPP__Real__Time__Tariff__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Real__Time__Tariff__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__SDP__Type_encoder(const DCA__3GPP__SDP__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_SDP_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__SDP__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SDP__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__SDP__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_SDP_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__SDP__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Announcement__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Announcement__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DNAS__NONE__Acct__Authentic_encoder(const DNAS__NONE__Acct__Authentic& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Acct_Authentic' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DNAS__NONE__Acct__Authentic_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__Acct__Authentic_decoder(OCTETSTRING& input_stream, DNAS__NONE__Acct__Authentic& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Acct_Authentic' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DNAS__NONE__Acct__Authentic_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Non__3GPP__User__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Non__3GPP__User__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Delivery__Report__Requested_encoder(const DCA__3GPP__Delivery__Report__Requested& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Delivery_Report_Requested' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Delivery__Report__Requested_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Delivery__Report__Requested_decoder(OCTETSTRING& input_stream, DCA__3GPP__Delivery__Report__Requested& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Delivery_Report_Requested' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Delivery__Report__Requested_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void RX__3GPP__Sponsored__Connectivity__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Sponsored__Connectivity__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Application__Server__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Application__Server__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Originator__Address_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Originator__Address_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__AESE__Communication__Pattern_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__AESE__Communication__Pattern_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__NBIFOM__Mode_encoder(const PCC__3GPP__NBIFOM__Mode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_NBIFOM_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__NBIFOM__Mode_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__NBIFOM__Mode_decoder(OCTETSTRING& input_stream, PCC__3GPP__NBIFOM__Mode& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_NBIFOM_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__NBIFOM__Mode_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Redirect__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Redirect__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__Originating__Request_encoder(const CxDx__3GPP__Originating__Request& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Originating_Request' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CxDx__3GPP__Originating__Request_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Originating__Request_decoder(OCTETSTRING& input_stream, CxDx__3GPP__Originating__Request& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Originating_Request' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CxDx__3GPP__Originating__Request_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__PRA__Remove_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__PRA__Remove_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Granted__Service__Unit_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Granted__Service__Unit_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Specific__APN__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Specific__APN__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Terminal__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Terminal__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__Restoration__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Restoration__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 MIPv4__NONE__MIP__HA__to__MN__MSA_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__HA__to__MN__MSA_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Call__Barring__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Call__Barring__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Service__Parameter__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Service__Parameter__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Talk__Burst__Exchange_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Talk__Burst__Exchange_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Time__Quota__Mechanism_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Time__Quota__Mechanism_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 RX__3GPP__Media__Sub__Component_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Media__Sub__Component_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__CN__Operator__Selection__Entity_encoder(const DCA__3GPP__CN__Operator__Selection__Entity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_CN_Operator_Selection_Entity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__CN__Operator__Selection__Entity_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__CN__Operator__Selection__Entity_decoder(OCTETSTRING& input_stream, DCA__3GPP__CN__Operator__Selection__Entity& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_CN_Operator_Selection_Entity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__CN__Operator__Selection__Entity_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Charging__Rule__Remove_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Charging__Rule__Remove_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Service__Report_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Service__Report_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Tunnel__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Tunnel__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__QoS__Rule__Definition_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__QoS__Rule__Definition_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Charging__Rule__Report_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Charging__Rule__Report_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Collection__Period__RRM__UMTS_encoder(const AAA__3GPP__Collection__Period__RRM__UMTS& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Collection_Period_RRM_UMTS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Collection__Period__RRM__UMTS_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Collection__Period__RRM__UMTS_decoder(OCTETSTRING& input_stream, AAA__3GPP__Collection__Period__RRM__UMTS& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Collection_Period_RRM_UMTS' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Collection__Period__RRM__UMTS_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Recipient__Received__Address_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Recipient__Received__Address_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__DCD__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__DCD__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Location__Estimate__Type_encoder(const DCA__3GPP__Location__Estimate__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Location_Estimate_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Location__Estimate__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Location__Estimate__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__Location__Estimate__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Location_Estimate_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Location__Estimate__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Addressee__Type_encoder(const DCA__3GPP__Addressee__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Addressee_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Addressee__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Addressee__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__Addressee__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Addressee_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Addressee__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__TWAN__Connectivity__Parameters_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__TWAN__Connectivity__Parameters_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Participant__Access__Priority_encoder(const DCA__3GPP__Participant__Access__Priority& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Participant_Access_Priority' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Participant__Access__Priority_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Participant__Access__Priority_decoder(OCTETSTRING& input_stream, DCA__3GPP__Participant__Access__Priority& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Participant_Access_Priority' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Participant__Access__Priority_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv4__NONE__MIP__Algorithm__Type_encoder(const MIPv4__NONE__MIP__Algorithm__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.MIPv4_NONE_MIP_Algorithm_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(MIPv4__NONE__MIP__Algorithm__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__Algorithm__Type_decoder(OCTETSTRING& input_stream, MIPv4__NONE__MIP__Algorithm__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.MIPv4_NONE_MIP_Algorithm_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(MIPv4__NONE__MIP__Algorithm__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Location__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Location__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__LCS__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__LCS__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Service__Parameters_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Service__Parameters_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Presence__Reporting__Area__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Presence__Reporting__Area__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__SMS__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SMS__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Event__Trigger_encoder(const PCC__3GPP__Event__Trigger& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Event_Trigger' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Event__Trigger_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Event__Trigger_decoder(OCTETSTRING& input_stream, PCC__3GPP__Event__Trigger& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Event_Trigger' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Event__Trigger_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv6__NONE__QoS__Capability_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv6__NONE__QoS__Capability_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__ADC__Rule__Install_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__ADC__Rule__Install_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Non__IP__PDN__Type__Indicator_encoder(const AAA__3GPP__Non__IP__PDN__Type__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 `@DIAMETER_Types.AAA_3GPP_Non_IP_PDN_Type_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Non__IP__PDN__Type__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Non__IP__PDN__Type__Indicator_decoder(OCTETSTRING& input_stream, AAA__3GPP__Non__IP__PDN__Type__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 `@DIAMETER_Types.AAA_3GPP_Non_IP_PDN_Type_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Non__IP__PDN__Type__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 DCA__3GPP__Dynamic__Address__Flag_encoder(const DCA__3GPP__Dynamic__Address__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 `@DIAMETER_Types.DCA_3GPP_Dynamic_Address_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Dynamic__Address__Flag_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Dynamic__Address__Flag_decoder(OCTETSTRING& input_stream, DCA__3GPP__Dynamic__Address__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 `@DIAMETER_Types.DCA_3GPP_Dynamic_Address_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Dynamic__Address__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 AAA__3GPP__Authentication__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Authentication__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Transcoder__Inserted__Indication_encoder(const DCA__3GPP__Transcoder__Inserted__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Transcoder_Inserted_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Transcoder__Inserted__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Transcoder__Inserted__Indication_decoder(OCTETSTRING& input_stream, DCA__3GPP__Transcoder__Inserted__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Transcoder_Inserted_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Transcoder__Inserted__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__SMS__Node_encoder(const DCA__3GPP__SMS__Node& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_SMS_Node' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__SMS__Node_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SMS__Node_decoder(OCTETSTRING& input_stream, DCA__3GPP__SMS__Node& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_SMS_Node' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__SMS__Node_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DNAS__NONE__CHAP__Algorithm_encoder(const DNAS__NONE__CHAP__Algorithm& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_CHAP_Algorithm' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DNAS__NONE__CHAP__Algorithm_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__CHAP__Algorithm_decoder(OCTETSTRING& input_stream, DNAS__NONE__CHAP__Algorithm& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_CHAP_Algorithm' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DNAS__NONE__CHAP__Algorithm_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__APN__Configuration__Profile_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__APN__Configuration__Profile_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Message__Type_encoder(const DCA__3GPP__Message__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Message_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Message__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Message__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__Message__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Message_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Message__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__APN__Rate__Control__Uplink_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__APN__Rate__Control__Uplink_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__PDP__Context__Type_encoder(const DCA__3GPP__PDP__Context__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PDP_Context_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__PDP__Context__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PDP__Context__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__PDP__Context__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PDP_Context_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__PDP__Context__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void RX__3GPP__Flows_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Flows_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Privacy__Indicator_encoder(const DCA__3GPP__Privacy__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 `@DIAMETER_Types.DCA_3GPP_Privacy_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Privacy__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Privacy__Indicator_decoder(OCTETSTRING& input_stream, DCA__3GPP__Privacy__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 `@DIAMETER_Types.DCA_3GPP_Privacy_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Privacy__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 S6__3GPP__UE__Reachability__Configuration_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__UE__Reachability__Configuration_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 RX__3GPP__Acceptable__Service__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Acceptable__Service__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Flow__Direction_encoder(const PCC__3GPP__Flow__Direction& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Flow_Direction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Flow__Direction_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Flow__Direction_decoder(OCTETSTRING& input_stream, PCC__3GPP__Flow__Direction& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Flow_Direction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Flow__Direction_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__ProSe__Reason__For__Cancellation_encoder(const DCA__3GPP__ProSe__Reason__For__Cancellation& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_ProSe_Reason_For_Cancellation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__ProSe__Reason__For__Cancellation_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__ProSe__Reason__For__Cancellation_decoder(OCTETSTRING& input_stream, DCA__3GPP__ProSe__Reason__For__Cancellation& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_ProSe_Reason_For_Cancellation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__ProSe__Reason__For__Cancellation_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Session__Release__Cause_encoder(const PCC__3GPP__Session__Release__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 `@DIAMETER_Types.PCC_3GPP_Session_Release_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Session__Release__Cause_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Session__Release__Cause_decoder(OCTETSTRING& input_stream, PCC__3GPP__Session__Release__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 `@DIAMETER_Types.PCC_3GPP_Session_Release_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Session__Release__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 AAA__3GPP__MDT__User__Consent_encoder(const AAA__3GPP__MDT__User__Consent& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_MDT_User_Consent' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__MDT__User__Consent_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__MDT__User__Consent_decoder(OCTETSTRING& input_stream, AAA__3GPP__MDT__User__Consent& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_MDT_User_Consent' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__MDT__User__Consent_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__G__S__U__Pool__Reference_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__G__S__U__Pool__Reference_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Subscription__Data__Deletion_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Subscription__Data__Deletion_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__AoC__Request__Type_encoder(const DCA__3GPP__AoC__Request__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_AoC_Request_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__AoC__Request__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__AoC__Request__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__AoC__Request__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_AoC_Request_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__AoC__Request__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Network__Access__Mode_encoder(const AAA__3GPP__Network__Access__Mode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Network_Access_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Network__Access__Mode_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Network__Access__Mode_decoder(OCTETSTRING& input_stream, AAA__3GPP__Network__Access__Mode& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Network_Access_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Network__Access__Mode_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DNAS__NONE__Framed__Compression_encoder(const DNAS__NONE__Framed__Compression& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Framed_Compression' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DNAS__NONE__Framed__Compression_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__Framed__Compression_decoder(OCTETSTRING& input_stream, DNAS__NONE__Framed__Compression& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Framed_Compression' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DNAS__NONE__Framed__Compression_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DNAS__NONE__ARAP__Zone__Access_encoder(const DNAS__NONE__ARAP__Zone__Access& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_ARAP_Zone_Access' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DNAS__NONE__ARAP__Zone__Access_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__ARAP__Zone__Access_decoder(OCTETSTRING& input_stream, DNAS__NONE__ARAP__Zone__Access& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_ARAP_Zone_Access' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DNAS__NONE__ARAP__Zone__Access_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void QoSFilterRule_encoder(const CHARSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `charstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CHARSTRING_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER QoSFilterRule_decoder(OCTETSTRING& input_stream, CHARSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `charstring' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CHARSTRING_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Complete__Data__List__Included__Indicator_encoder(const AAA__3GPP__Complete__Data__List__Included__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 `@DIAMETER_Types.AAA_3GPP_Complete_Data_List_Included_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Complete__Data__List__Included__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Complete__Data__List__Included__Indicator_decoder(OCTETSTRING& input_stream, AAA__3GPP__Complete__Data__List__Included__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 `@DIAMETER_Types.AAA_3GPP_Complete_Data_List_Included_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Complete__Data__List__Included__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 DCA__3GPP__LCS__Client__Name_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__LCS__Client__Name_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__CC__Request__Type_encoder(const DCC__NONE__CC__Request__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_CC_Request_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__CC__Request__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__CC__Request__Type_decoder(OCTETSTRING& input_stream, DCC__NONE__CC__Request__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_CC_Request_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__CC__Request__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Event__Report__Indication_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Event__Report__Indication_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__MDT__Configuration_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__MDT__Configuration_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Usage__Monitoring__Report_encoder(const PCC__3GPP__Usage__Monitoring__Report& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Usage_Monitoring_Report' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Usage__Monitoring__Report_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Usage__Monitoring__Report_decoder(OCTETSTRING& input_stream, PCC__3GPP__Usage__Monitoring__Report& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Usage_Monitoring_Report' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Usage__Monitoring__Report_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__Priviledged__Sender__Indication_encoder(const CxDx__3GPP__Priviledged__Sender__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Priviledged_Sender_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CxDx__3GPP__Priviledged__Sender__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Priviledged__Sender__Indication_decoder(OCTETSTRING& input_stream, CxDx__3GPP__Priviledged__Sender__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Priviledged_Sender_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CxDx__3GPP__Priviledged__Sender__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Adjacent__Access__Restriction__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Adjacent__Access__Restriction__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__AoC__Service__Obligatory__Type_encoder(const DCA__3GPP__AoC__Service__Obligatory__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_AoC_Service_Obligatory_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__AoC__Service__Obligatory__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__AoC__Service__Obligatory__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__AoC__Service__Obligatory__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_AoC_Service_Obligatory_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__AoC__Service__Obligatory__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Default__EPS__Bearer__QoS_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Default__EPS__Bearer__QoS_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__ICS__Indicator_encoder(const AAA__3GPP__ICS__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 `@DIAMETER_Types.AAA_3GPP_ICS_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__ICS__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__ICS__Indicator_decoder(OCTETSTRING& input_stream, AAA__3GPP__ICS__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 `@DIAMETER_Types.AAA_3GPP_ICS_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__ICS__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 AAA__3GPP__Cancellation__Type_encoder(const AAA__3GPP__Cancellation__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Cancellation_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Cancellation__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Cancellation__Type_decoder(OCTETSTRING& input_stream, AAA__3GPP__Cancellation__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Cancellation_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Cancellation__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AVP__Data_avp__BASE__NONE__E2E__Sequence_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__Data_avp__BASE__NONE__E2E__Sequence_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__PDN__Type_encoder(const AAA__3GPP__PDN__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_PDN_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__PDN__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__PDN__Type_decoder(OCTETSTRING& input_stream, AAA__3GPP__PDN__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_PDN_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__PDN__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Scale__Factor_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Scale__Factor_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__IM__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__IM__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DNAS__NONE__Prompt_encoder(const DNAS__NONE__Prompt& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Prompt' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DNAS__NONE__Prompt_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__Prompt_decoder(OCTETSTRING& input_stream, DNAS__NONE__Prompt& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Prompt' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DNAS__NONE__Prompt_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__MM__Content__Type_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__MM__Content__Type_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__CPDT__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__CPDT__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__LCS__Requestor__Id_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__LCS__Requestor__Id_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 RX__3GPP__Access__Network__Charging__Identifier_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Access__Network__Charging__Identifier_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Redirect__Server_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Redirect__Server_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__AESE__Communication__Pattern__Config__Status_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__AESE__Communication__Pattern__Config__Status_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__PoC__User__Role__info__Units_encoder(const DCA__3GPP__PoC__User__Role__info__Units& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_User_Role_info_Units' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__PoC__User__Role__info__Units_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PoC__User__Role__info__Units_decoder(OCTETSTRING& input_stream, DCA__3GPP__PoC__User__Role__info__Units& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_User_Role_info_Units' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__PoC__User__Role__info__Units_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Variable__Part_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Variable__Part_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Enhanced__Coverage__Restriction__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Enhanced__Coverage__Restriction__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Bearer__Operation_encoder(const PCC__3GPP__Bearer__Operation& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Bearer_Operation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Bearer__Operation_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Bearer__Operation_decoder(OCTETSTRING& input_stream, PCC__3GPP__Bearer__Operation& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Bearer_Operation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Bearer__Operation_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Current__Location__Retrieved_encoder(const AAA__3GPP__Current__Location__Retrieved& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Current_Location_Retrieved' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Current__Location__Retrieved_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Current__Location__Retrieved_decoder(OCTETSTRING& input_stream, AAA__3GPP__Current__Location__Retrieved& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Current_Location_Retrieved' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Current__Location__Retrieved_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__SM__Device__Trigger__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SM__Device__Trigger__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Service__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Service__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Packet__Filter__Usage_encoder(const PCC__3GPP__Packet__Filter__Usage& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Packet_Filter_Usage' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Packet__Filter__Usage_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Packet__Filter__Usage_decoder(OCTETSTRING& input_stream, PCC__3GPP__Packet__Filter__Usage& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Packet_Filter_Usage' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Packet__Filter__Usage_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Inter__Operator__Identifier_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Inter__Operator__Identifier_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__RDS__Indicator_encoder(const AAA__3GPP__RDS__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 `@DIAMETER_Types.AAA_3GPP_RDS_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__RDS__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__RDS__Indicator_decoder(OCTETSTRING& input_stream, AAA__3GPP__RDS__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 `@DIAMETER_Types.AAA_3GPP_RDS_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__RDS__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 PCC__3GPP__Conditional__APN__Aggregate__Max__Bitrate_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Conditional__APN__Aggregate__Max__Bitrate_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Reply__Path__Requested_encoder(const DCA__3GPP__Reply__Path__Requested& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Reply_Path_Requested' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Reply__Path__Requested_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Reply__Path__Requested_decoder(OCTETSTRING& input_stream, DCA__3GPP__Reply__Path__Requested& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Reply_Path_Requested' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Reply__Path__Requested_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Serving__Node__Type_encoder(const DCA__3GPP__Serving__Node__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Serving_Node_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Serving__Node__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Serving__Node__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__Serving__Node__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Serving_Node_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Serving__Node__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Requested__UTRAN__GERAN__Authentication__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Requested__UTRAN__GERAN__Authentication__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__EPS__User__State_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__EPS__User__State_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__CP__CIoT__EPS__Optimisation__Indicator_encoder(const DCA__3GPP__CP__CIoT__EPS__Optimisation__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 `@DIAMETER_Types.DCA_3GPP_CP_CIoT_EPS_Optimisation_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__CP__CIoT__EPS__Optimisation__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__CP__CIoT__EPS__Optimisation__Indicator_decoder(OCTETSTRING& input_stream, DCA__3GPP__CP__CIoT__EPS__Optimisation__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 `@DIAMETER_Types.DCA_3GPP_CP_CIoT_EPS_Optimisation_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__CP__CIoT__EPS__Optimisation__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 DCA__3GPP__NNI__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__NNI__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Offline__Charging_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Offline__Charging_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Additional__Content__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Additional__Content__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Resource__Release__Notification_encoder(const PCC__3GPP__Resource__Release__Notification& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Resource_Release_Notification' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Resource__Release__Notification_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Resource__Release__Notification_decoder(OCTETSTRING& input_stream, PCC__3GPP__Resource__Release__Notification& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Resource_Release_Notification' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Resource__Release__Notification_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Error__Diagnostic_encoder(const AAA__3GPP__Error__Diagnostic& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Error_Diagnostic' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Error__Diagnostic_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Error__Diagnostic_decoder(OCTETSTRING& input_stream, AAA__3GPP__Error__Diagnostic& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Error_Diagnostic' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Error__Diagnostic_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__MMS__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__MMS__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Routing__Rule__Definition_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Routing__Rule__Definition_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__VPLMN__Dynamic__Address__Allowed_encoder(const AAA__3GPP__VPLMN__Dynamic__Address__Allowed& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_VPLMN_Dynamic_Address_Allowed' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__VPLMN__Dynamic__Address__Allowed_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__VPLMN__Dynamic__Address__Allowed_decoder(OCTETSTRING& input_stream, AAA__3GPP__VPLMN__Dynamic__Address__Allowed& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_VPLMN_Dynamic_Address_Allowed' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__VPLMN__Dynamic__Address__Allowed_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void INT64_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(INT64_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER INT64_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(INT64_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv4__NONE__MIP__MN__AAA__Auth_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__MN__AAA__Auth_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Service__Type_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Service__Type_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Local__GW__Inserted__Indication_encoder(const DCA__3GPP__Local__GW__Inserted__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Local_GW_Inserted_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Local__GW__Inserted__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Local__GW__Inserted__Indication_decoder(OCTETSTRING& input_stream, DCA__3GPP__Local__GW__Inserted__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Local_GW_Inserted_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Local__GW__Inserted__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__Final__Unit__Indication_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Final__Unit__Indication_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__User__State_encoder(const AAA__3GPP__User__State& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_User_State' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__User__State_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__User__State_decoder(OCTETSTRING& input_stream, AAA__3GPP__User__State& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_User_State' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__User__State_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv4__NONE__MIP__MN__to__HA__MSA_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__MN__to__HA__MSA_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Envelope_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Envelope_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Monitoring__Event__Configuration__Activity_encoder(const DCA__3GPP__Monitoring__Event__Configuration__Activity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Monitoring_Event_Configuration_Activity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Monitoring__Event__Configuration__Activity_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Monitoring__Event__Configuration__Activity_decoder(OCTETSTRING& input_stream, DCA__3GPP__Monitoring__Event__Configuration__Activity& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Monitoring_Event_Configuration_Activity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Monitoring__Event__Configuration__Activity_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Trust__Relationship__Update_encoder(const AAA__3GPP__Trust__Relationship__Update& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Trust_Relationship_Update' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Trust__Relationship__Update_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Trust__Relationship__Update_decoder(OCTETSTRING& input_stream, AAA__3GPP__Trust__Relationship__Update& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Trust_Relationship_Update' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Trust__Relationship__Update_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__APN__Rate__Control__Downlink_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__APN__Rate__Control__Downlink_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Session__Direction_encoder(const DCA__3GPP__Session__Direction& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Session_Direction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Session__Direction_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Session__Direction_decoder(OCTETSTRING& input_stream, DCA__3GPP__Session__Direction& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Session_Direction' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Session__Direction_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__TFT__Packet__Filter__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__TFT__Packet__Filter__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Transmitter__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Transmitter__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__PS__Furnish__Charging__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PS__Furnish__Charging__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__Associated__Identities_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Associated__Identities_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Session__Linking__Indicator_encoder(const PCC__3GPP__Session__Linking__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 `@DIAMETER_Types.PCC_3GPP_Session_Linking_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Session__Linking__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Session__Linking__Indicator_decoder(OCTETSTRING& input_stream, PCC__3GPP__Session__Linking__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 `@DIAMETER_Types.PCC_3GPP_Session_Linking_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Session__Linking__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 PCC__3GPP__PRA__Install_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__PRA__Install_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__QoS__Negotiation_encoder(const PCC__3GPP__QoS__Negotiation& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_QoS_Negotiation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__QoS__Negotiation_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__QoS__Negotiation_decoder(OCTETSTRING& input_stream, PCC__3GPP__QoS__Negotiation& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_QoS_Negotiation' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__QoS__Negotiation_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__LIPA__Permission_encoder(const AAA__3GPP__LIPA__Permission& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_LIPA_Permission' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__LIPA__Permission_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__LIPA__Permission_decoder(OCTETSTRING& input_stream, AAA__3GPP__LIPA__Permission& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_LIPA_Permission' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__LIPA__Permission_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__SIP__Auth__Data__Item_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__SIP__Auth__Data__Item_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 MIPv4__NONE__MIP__FA__to__MN__MSA_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__FA__to__MN__MSA_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Subscription__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Subscription__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__Multiple__Registration__Indication_encoder(const CxDx__3GPP__Multiple__Registration__Indication& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Multiple_Registration_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CxDx__3GPP__Multiple__Registration__Indication_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Multiple__Registration__Indication_decoder(OCTETSTRING& input_stream, CxDx__3GPP__Multiple__Registration__Indication& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Multiple_Registration_Indication' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CxDx__3GPP__Multiple__Registration__Indication_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void BASE__NONE__Vendor__Specific__Application__Id_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Vendor__Specific__Application__Id_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__IMSI__Unauthenticated__Flag_encoder(const DCA__3GPP__IMSI__Unauthenticated__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 `@DIAMETER_Types.DCA_3GPP_IMSI_Unauthenticated_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__IMSI__Unauthenticated__Flag_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__IMSI__Unauthenticated__Flag_decoder(OCTETSTRING& input_stream, DCA__3GPP__IMSI__Unauthenticated__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 `@DIAMETER_Types.DCA_3GPP_IMSI_Unauthenticated_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__IMSI__Unauthenticated__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 AAA__3GPP__CSG__Subscription__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__CSG__Subscription__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__AN__Trusted_encoder(const AAA__3GPP__AN__Trusted& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_AN_Trusted' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__AN__Trusted_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__AN__Trusted_decoder(OCTETSTRING& input_stream, AAA__3GPP__AN__Trusted& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_AN_Trusted' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__AN__Trusted_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Monitoring__Event__Funtionality_encoder(const DCA__3GPP__Monitoring__Event__Funtionality& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Monitoring_Event_Funtionality' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Monitoring__Event__Funtionality_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Monitoring__Event__Funtionality_decoder(OCTETSTRING& input_stream, DCA__3GPP__Monitoring__Event__Funtionality& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Monitoring_Event_Funtionality' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Monitoring__Event__Funtionality_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Charging__Rule__Install_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Charging__Rule__Install_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 RX__3GPP__Rx__Request__Type_encoder(const RX__3GPP__Rx__Request__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Rx_Request_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__Rx__Request__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Rx__Request__Type_decoder(OCTETSTRING& input_stream, RX__3GPP__Rx__Request__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Rx_Request_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__Rx__Request__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void S6__3GPP__NIDD__Authorization__Response_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__NIDD__Authorization__Response_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Transport__Access__Type_encoder(const AAA__3GPP__Transport__Access__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Transport_Access_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Transport__Access__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Transport__Access__Type_decoder(OCTETSTRING& input_stream, AAA__3GPP__Transport__Access__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Transport_Access_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Transport__Access__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__Subscription__Id_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Subscription__Id_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__QoS__Rule__Remove_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__QoS__Rule__Remove_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__VPLMN__CSG__Subscription__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__VPLMN__CSG__Subscription__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Message__Body_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Message__Body_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Incremental__Cost_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Incremental__Cost_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Usage__Monitoring__Level_encoder(const PCC__3GPP__Usage__Monitoring__Level& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Usage_Monitoring_Level' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Usage__Monitoring__Level_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Usage__Monitoring__Level_decoder(OCTETSTRING& input_stream, PCC__3GPP__Usage__Monitoring__Level& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Usage_Monitoring_Level' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Usage__Monitoring__Level_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Collection__Period__RRM__LTE_encoder(const AAA__3GPP__Collection__Period__RRM__LTE& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Collection_Period_RRM_LTE' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Collection__Period__RRM__LTE_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Collection__Period__RRM__LTE_decoder(OCTETSTRING& input_stream, AAA__3GPP__Collection__Period__RRM__LTE& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Collection_Period_RRM_LTE' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Collection__Period__RRM__LTE_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Subscriber__Status_encoder(const AAA__3GPP__Subscriber__Status& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Subscriber_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Subscriber__Status_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Subscriber__Status_decoder(OCTETSTRING& input_stream, AAA__3GPP__Subscriber__Status& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AAA_3GPP_Subscriber_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Subscriber__Status_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__Identity__with__Emergency__Registration_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Identity__with__Emergency__Registration_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Originator__Received__Address_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Originator__Received__Address_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__AoC__Service_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__AoC__Service_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCC__NONE__Tariff__Change__Usage_encoder(const DCC__NONE__Tariff__Change__Usage& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Tariff_Change_Usage' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCC__NONE__Tariff__Change__Usage_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Tariff__Change__Usage_decoder(OCTETSTRING& input_stream, DCC__NONE__Tariff__Change__Usage& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCC_NONE_Tariff_Change_Usage' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCC__NONE__Tariff__Change__Usage_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__LCS__PrivacyException_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__LCS__PrivacyException_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Read__Reply__Report__Requested_encoder(const DCA__3GPP__Read__Reply__Report__Requested& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Read_Reply_Report_Requested' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Read__Reply__Report__Requested_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Read__Reply__Report__Requested_decoder(OCTETSTRING& input_stream, DCA__3GPP__Read__Reply__Report__Requested& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Read_Reply_Report_Requested' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Read__Reply__Report__Requested_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DNAS__NONE__CHAP__Auth_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__CHAP__Auth_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__SDP__TimeStamps_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SDP__TimeStamps_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Related__Trigger_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Related__Trigger_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Enhanced__Coverage__Restriction_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Enhanced__Coverage__Restriction_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__User__Data__Already__Available_encoder(const CxDx__3GPP__User__Data__Already__Available& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_User_Data_Already_Available' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CxDx__3GPP__User__Data__Already__Available_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__User__Data__Already__Available_decoder(OCTETSTRING& input_stream, CxDx__3GPP__User__Data__Already__Available& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_User_Data_Already_Available' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CxDx__3GPP__User__Data__Already__Available_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void MIPv4__NONE__MIP__Home__Agent__Host_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER MIPv4__NONE__MIP__Home__Agent__Host_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__MMTel__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__MMTel__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Charging__Characteristics__Selection__Mode_encoder(const DCA__3GPP__Charging__Characteristics__Selection__Mode& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Charging_Characteristics_Selection_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Charging__Characteristics__Selection__Mode_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Charging__Characteristics__Selection__Mode_decoder(OCTETSTRING& input_stream, DCA__3GPP__Charging__Characteristics__Selection__Mode& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Charging_Characteristics_Selection_Mode' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Charging__Characteristics__Selection__Mode_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCC__NONE__Multiple__Services__Credit__Control_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCC__NONE__Multiple__Services__Credit__Control_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__All__APN__Configurations__Included__Indicator_encoder(const AAA__3GPP__All__APN__Configurations__Included__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 `@DIAMETER_Types.AAA_3GPP_All_APN_Configurations_Included_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__All__APN__Configurations__Included__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__All__APN__Configurations__Included__Indicator_decoder(OCTETSTRING& input_stream, AAA__3GPP__All__APN__Configurations__Included__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 `@DIAMETER_Types.AAA_3GPP_All_APN_Configurations_Included_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__All__APN__Configurations__Included__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 AAA__3GPP__External__Client_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__External__Client_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Charge__Reason__Code_encoder(const DCA__3GPP__Charge__Reason__Code& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Charge_Reason_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Charge__Reason__Code_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Charge__Reason__Code_decoder(OCTETSTRING& input_stream, DCA__3GPP__Charge__Reason__Code& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Charge_Reason_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Charge__Reason__Code_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__TWAN__PCO_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__TWAN__PCO_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__PoC__Change__Conditions_encoder(const DCA__3GPP__PoC__Change__Conditions& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_Change_Conditions' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__PoC__Change__Conditions_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PoC__Change__Conditions_decoder(OCTETSTRING& input_stream, DCA__3GPP__PoC__Change__Conditions& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_Change_Conditions' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__PoC__Change__Conditions_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DNAS__NONE__Accounting__Auth__Method_encoder(const DNAS__NONE__Accounting__Auth__Method& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Accounting_Auth_Method' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DNAS__NONE__Accounting__Auth__Method_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DNAS__NONE__Accounting__Auth__Method_decoder(OCTETSTRING& input_stream, DNAS__NONE__Accounting__Auth__Method& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DNAS_NONE_Accounting_Auth_Method' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DNAS__NONE__Accounting__Auth__Method_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__MBMS__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__MBMS__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 S6__3GPP__Supported__Services_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__Supported__Services_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Radio__Parameter__Set__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Radio__Parameter__Set__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Relay__Node__Indicator_encoder(const AAA__3GPP__Relay__Node__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 `@DIAMETER_Types.AAA_3GPP_Relay_Node_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AAA__3GPP__Relay__Node__Indicator_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Relay__Node__Indicator_decoder(OCTETSTRING& input_stream, AAA__3GPP__Relay__Node__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 `@DIAMETER_Types.AAA_3GPP_Relay_Node_Indicator' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AAA__3GPP__Relay__Node__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 S6__3GPP__T4__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER S6__3GPP__T4__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Fixed__User__Location__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Fixed__User__Location__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Coverage__Status_encoder(const DCA__3GPP__Coverage__Status& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Coverage_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Coverage__Status_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Coverage__Status_decoder(OCTETSTRING& input_stream, DCA__3GPP__Coverage__Status& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Coverage_Status' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Coverage__Status_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Online_encoder(const PCC__3GPP__Online& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Online' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Online_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Online_decoder(OCTETSTRING& input_stream, PCC__3GPP__Online& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Online' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Online_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__MBMS__Charged__Party_encoder(const DCA__3GPP__MBMS__Charged__Party& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_MBMS_Charged_Party' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__MBMS__Charged__Party_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__MBMS__Charged__Party_decoder(OCTETSTRING& input_stream, DCA__3GPP__MBMS__Charged__Party& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_MBMS_Charged_Party' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__MBMS__Charged__Party_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__AoC__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__AoC__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__Supported__Features_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Supported__Features_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__Local__Time__Zone_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Local__Time__Zone_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__GERAN__Vector_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__GERAN__Vector_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Online__Charging__Flag_encoder(const DCA__3GPP__Online__Charging__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 `@DIAMETER_Types.DCA_3GPP_Online_Charging_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Online__Charging__Flag_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Online__Charging__Flag_decoder(OCTETSTRING& input_stream, DCA__3GPP__Online__Charging__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 `@DIAMETER_Types.DCA_3GPP_Online_Charging_Flag' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Online__Charging__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 AAA__3GPP__EPS__Subscribed__QoS__Profile_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__EPS__Subscribed__QoS__Profile_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__GPRS__Subscription__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__GPRS__Subscription__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Access__Transfer__Type_encoder(const DCA__3GPP__Access__Transfer__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Access_Transfer_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Access__Transfer__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Access__Transfer__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__Access__Transfer__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Access_Transfer_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Access__Transfer__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Inter__UE__Transfer_encoder(const DCA__3GPP__Inter__UE__Transfer& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Inter_UE_Transfer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Inter__UE__Transfer_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Inter__UE__Transfer_decoder(OCTETSTRING& input_stream, DCA__3GPP__Inter__UE__Transfer& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_Inter_UE_Transfer' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Inter__UE__Transfer_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void BASE__NONE__Termination__Cause_encoder(const BASE__NONE__Termination__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 `@DIAMETER_Types.BASE_NONE_Termination_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(BASE__NONE__Termination__Cause_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER BASE__NONE__Termination__Cause_decoder(OCTETSTRING& input_stream, BASE__NONE__Termination__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 `@DIAMETER_Types.BASE_NONE_Termination_Cause' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(BASE__NONE__Termination__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 DCA__3GPP__Class__Identifier_encoder(const DCA__3GPP__Class__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 `@DIAMETER_Types.DCA_3GPP_Class_Identifier' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__Class__Identifier_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Class__Identifier_decoder(OCTETSTRING& input_stream, DCA__3GPP__Class__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 `@DIAMETER_Types.DCA_3GPP_Class_Identifier' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__Class__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 RX__3GPP__Specific__Action_encoder(const RX__3GPP__Specific__Action& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Specific_Action' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__Specific__Action_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__Specific__Action_decoder(OCTETSTRING& input_stream, RX__3GPP__Specific__Action& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_Specific_Action' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__Specific__Action_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__Time__Stamps_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Time__Stamps_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__UWAN__User__Location__Info_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__UWAN__User__Location__Info_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__ProSe__Role__Of__UE_encoder(const DCA__3GPP__ProSe__Role__Of__UE& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_ProSe_Role_Of_UE' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__ProSe__Role__Of__UE_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__ProSe__Role__Of__UE_decoder(OCTETSTRING& input_stream, DCA__3GPP__ProSe__Role__Of__UE& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_ProSe_Role_Of_UE' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__ProSe__Role__Of__UE_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__RAT__Type_encoder(const PCC__3GPP__RAT__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_RAT_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__RAT__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__RAT__Type_decoder(OCTETSTRING& input_stream, PCC__3GPP__RAT__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_RAT_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__RAT__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__PoC__Session__Type_encoder(const DCA__3GPP__PoC__Session__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_Session_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__PoC__Session__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__PoC__Session__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__PoC__Session__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_PoC_Session_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__PoC__Session__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void DCA__3GPP__ISUP__Cause_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__ISUP__Cause_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 RX__3GPP__AF__Signalling__Protocol_encoder(const RX__3GPP__AF__Signalling__Protocol& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_AF_Signalling_Protocol' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(RX__3GPP__AF__Signalling__Protocol_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER RX__3GPP__AF__Signalling__Protocol_decoder(OCTETSTRING& input_stream, RX__3GPP__AF__Signalling__Protocol& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.RX_3GPP_AF_Signalling_Protocol' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(RX__3GPP__AF__Signalling__Protocol_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Adjacent__PLMNs_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Adjacent__PLMNs_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__SGSN__Location__Information_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__SGSN__Location__Information_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 CxDx__3GPP__Reason__Code_encoder(const CxDx__3GPP__Reason__Code& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Reason_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(CxDx__3GPP__Reason__Code_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Reason__Code_decoder(OCTETSTRING& input_stream, CxDx__3GPP__Reason__Code& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.CxDx_3GPP_Reason_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(CxDx__3GPP__Reason__Code_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__Pre__emption__Vulnerability_encoder(const PCC__3GPP__Pre__emption__Vulnerability& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Pre_emption_Vulnerability' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Pre__emption__Vulnerability_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Pre__emption__Vulnerability_decoder(OCTETSTRING& input_stream, PCC__3GPP__Pre__emption__Vulnerability& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Pre_emption_Vulnerability' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Pre__emption__Vulnerability_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__Equivalent__PLMN__List_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__Equivalent__PLMN__List_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 PCC__3GPP__Default__Access_encoder(const PCC__3GPP__Default__Access& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Default_Access' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__Default__Access_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__Default__Access_decoder(OCTETSTRING& input_stream, PCC__3GPP__Default__Access& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_Default_Access' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__Default__Access_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void CxDx__3GPP__Supported__Applications_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER CxDx__3GPP__Supported__Applications_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__SM__Message__Type_encoder(const DCA__3GPP__SM__Message__Type& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_SM_Message_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(DCA__3GPP__SM__Message__Type_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__SM__Message__Type_decoder(OCTETSTRING& input_stream, DCA__3GPP__SM__Message__Type& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.DCA_3GPP_SM_Message_Type' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(DCA__3GPP__SM__Message__Type_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void PCC__3GPP__PS__to__CS__Session__Continuity_encoder(const PCC__3GPP__PS__to__CS__Session__Continuity& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_PS_to_CS_Session_Continuity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PCC__3GPP__PS__to__CS__Session__Continuity_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PCC__3GPP__PS__to__CS__Session__Continuity_decoder(OCTETSTRING& input_stream, PCC__3GPP__PS__to__CS__Session__Continuity& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PCC_3GPP_PS_to_CS_Session_Continuity' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PCC__3GPP__PS__to__CS__Session__Continuity_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AAA__3GPP__V2X__Subscription__Data_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__V2X__Subscription__Data_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 DCA__3GPP__Rate__Element_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER DCA__3GPP__Rate__Element_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AAA__3GPP__AMBR_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AAA__3GPP__AMBR_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AVP__Data_avp__UNKNOWN_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 AVP__Data_avp__UNKNOWN_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 AVP__Data_encoder(const AVP__Data& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Data' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__Data_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__Data_decoder(OCTETSTRING& input_stream, AVP__Data& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Data' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 AVP_avp__data_encoder(const AVP__Data& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Data' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP_avp__data_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP_avp__data_decoder(OCTETSTRING& input_stream, AVP__Data& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP_Data' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP_avp__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 AVP_encoder(const AVP& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP_decoder(OCTETSTRING& input_stream, AVP& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.AVP' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void Undefined__AVP_avp__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(Undefined__AVP_avp__length_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER Undefined__AVP_avp__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(Undefined__AVP_avp__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 Undefined__AVP_avp__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 Undefined__AVP_avp__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 Undefined__AVP_vendor__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(Undefined__AVP_vendor__id_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER Undefined__AVP_vendor__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(Undefined__AVP_vendor__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 Undefined__AVP_encoder(const Undefined__AVP& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.Undefined_AVP' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(Undefined__AVP_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER Undefined__AVP_decoder(OCTETSTRING& input_stream, Undefined__AVP& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.Undefined_AVP' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(Undefined__AVP_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void GenericAVP_avp__UNKNOWN_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 GenericAVP_avp__UNKNOWN_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 GenericAVP_encoder(const GenericAVP& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.GenericAVP' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(GenericAVP_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER GenericAVP_decoder(OCTETSTRING& input_stream, GenericAVP& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.GenericAVP' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(GenericAVP_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void AVP__list_encoder(const AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(AVP__list_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER AVP__list_decoder(OCTETSTRING& input_stream, AVP__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 `@DIAMETER_Types.AVP_list' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(AVP__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 f__get__R__bit(const PDU__DIAMETER& pl__pdu)
{
TTCN_Location current_location("DIAMETER_Types.ttcn", 453, TTCN_Location::LOCATION_FUNCTION, "f_get_R_bit");
current_location.update_lineno(455);
/* DIAMETER_Types.ttcn, line 455 */
return (const_cast< const PDU__DIAMETER&>(pl__pdu).RPETxxxx()[0] == bs_4);
}

OCTETSTRING f__DIAMETER__genEndToEnd()
{
TTCN_Location current_location("DIAMETER_Types.ttcn", 458, TTCN_Location::LOCATION_FUNCTION, "f_DIAMETER_genEndToEnd");
current_location.update_lineno(460);
/* DIAMETER_Types.ttcn, line 460 */
return f__DIAMETER__genEndToEnd__oct();
}

OCTETSTRING f__DIAMETER__genHopByHop()
{
TTCN_Location current_location("DIAMETER_Types.ttcn", 463, TTCN_Location::LOCATION_FUNCTION, "f_DIAMETER_genHopByHop");
current_location.update_lineno(465);
/* DIAMETER_Types.ttcn, line 465 */
return f__DIAMETER__genHopByHop__oct();
}

void integerList_0_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 integerList_0_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 integerList_encoder(const integerList& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.integerList' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(integerList_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER integerList_decoder(OCTETSTRING& input_stream, integerList& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.integerList' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(integerList_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void UINT8_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(UINT8_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER UINT8_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(UINT8_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void FLOAT32_encoder(const FLOAT& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `float' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(FLOAT32_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER FLOAT32_decoder(OCTETSTRING& input_stream, FLOAT& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `float' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(FLOAT32_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void FLOAT64_encoder(const FLOAT& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `float' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(FLOAT64_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER FLOAT64_decoder(OCTETSTRING& input_stream, FLOAT& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `float' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(FLOAT64_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.get_string(input_stream);
return 0;
case TTCN_EncDec::ET_INCOMPL_MSG:
case TTCN_EncDec::ET_LEN_ERR:
return 2;
default:
return 1;
}
}

void OCTET8_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(OCTET8_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER OCTET8_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(OCTET8_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.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__DIAMETER_message__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(PDU__DIAMETER_message__length_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PDU__DIAMETER_message__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(PDU__DIAMETER_message__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 Command__Code_encoder(const Command__Code& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.Command_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(Command__Code_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER Command__Code_decoder(OCTETSTRING& input_stream, Command__Code& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.Command_Code' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(Command__Code_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_buf.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__DIAMETER_encoder(const PDU__DIAMETER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, TRUE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PDU_DIAMETER' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf;
input_value.encode(PDU__DIAMETER_descr_, ttcn_buf, coding_type, extra_options);
ttcn_buf.get_string(output_stream);
}

INTEGER PDU__DIAMETER_decoder(OCTETSTRING& input_stream, PDU__DIAMETER& output_value, const UNIVERSAL_CHARSTRING& coding_name)
{
TTCN_EncDec::coding_t coding_type;
unsigned int extra_options = 0;
TTCN_EncDec::get_coding_from_str(coding_name, &coding_type, &extra_options, FALSE);
if (coding_type != TTCN_EncDec::CT_RAW) {
TTCN_Logger::begin_event_log2str();
coding_name.log();
TTCN_error("Type `@DIAMETER_Types.PDU_DIAMETER' does not support %s encoding", (const char*) TTCN_Logger::end_event_log2str());
}
TTCN_Buffer ttcn_buf(input_stream);
output_value.decode(PDU__DIAMETER_descr_, ttcn_buf, coding_type, extra_options);
switch (TTCN_EncDec::get_last_error_type()) {
case TTCN_EncDec::ET_NONE:
ttcn_buf.cut();
ttcn_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("DIAMETER_Types.ttcn", 0, TTCN_Location::LOCATION_UNKNOWN, "DIAMETER_Types");
module_object.add_function("f_DIAMETER_Enc", (genericfunc_t)&f__DIAMETER__Enc, NULL);
module_object.add_function("f_DIAMETER_Dec", (genericfunc_t)&f__DIAMETER__Dec, NULL);
module_object.add_function("f_DIAMETER_Enc_fast", (genericfunc_t)&f__DIAMETER__Enc__fast, NULL);
module_object.add_function("f_DIAMETER_Dec_fast", (genericfunc_t)&f__DIAMETER__Dec__fast, NULL);
module_object.add_function("f_DIAMETER_genHopByHop_oct", (genericfunc_t)&f__DIAMETER__genHopByHop__oct, NULL);
module_object.add_function("f_DIAMETER_genEndToEnd_oct", (genericfunc_t)&f__DIAMETER__genEndToEnd__oct, NULL);
module_object.add_function("f_DIAMETER_GetAVPByListOfCodes", (genericfunc_t)&f__DIAMETER__GetAVPByListOfCodes, NULL);
module_object.add_function("f_DIAMETER_GetAVPByListOfCodesCombined", (genericfunc_t)&f__DIAMETER__GetAVPByListOfCodesCombined, NULL);
module_object.add_function("f_DIAMETER_GetAVPByListOfCodesFromGroupedAVP", (genericfunc_t)&f__DIAMETER__GetAVPByListOfCodesFromGroupedAVP, NULL);
module_object.add_function("f_get_R_bit", (genericfunc_t)&f__get__R__bit, NULL);
module_object.add_function("f_DIAMETER_genEndToEnd", (genericfunc_t)&f__DIAMETER__genEndToEnd, NULL);
module_object.add_function("f_DIAMETER_genHopByHop", (genericfunc_t)&f__DIAMETER__genHopByHop, NULL);
current_location.update_lineno(12443);
/* DIAMETER_Types.ttcn, line 12443 */
const_c__AVP__Code__GI__3GPP__3GPP__SGSN__IPv6__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__SGSN__IPv6__Address;
current_location.update_lineno(12445);
/* DIAMETER_Types.ttcn, line 12445 */
const_c__AVP__Code__DNAS__NONE__Login__LAT__Service.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Login__LAT__Service;
current_location.update_lineno(12447);
/* DIAMETER_Types.ttcn, line 12447 */
const_c__AVP__Code__AAA__3GPP__RAR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__RAR__Flags;
current_location.update_lineno(12449);
/* DIAMETER_Types.ttcn, line 12449 */
const_c__AVP__Code__DCA__3GPP__SCS__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SCS__Address;
current_location.update_lineno(12451);
/* DIAMETER_Types.ttcn, line 12451 */
const_c__AVP__Code__GI__3GPP__3GPP__GGSN__MCC__MNC.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__GGSN__MCC__MNC;
current_location.update_lineno(12453);
/* DIAMETER_Types.ttcn, line 12453 */
const_c__AVP__Code__DCC__NONE__Direct__Debiting__Failure__Handling.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Direct__Debiting__Failure__Handling;
current_location.update_lineno(12455);
/* DIAMETER_Types.ttcn, line 12455 */
const_c__AVP__Code__MIPv6__NONE__MIP__Careof__Address.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__MIP__Careof__Address;
current_location.update_lineno(12457);
/* DIAMETER_Types.ttcn, line 12457 */
const_c__AVP__Code__DCA__3GPP__TWAN__User__Location__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__TWAN__User__Location__Info;
current_location.update_lineno(12459);
/* DIAMETER_Types.ttcn, line 12459 */
const_c__AVP__Code__DCA__3GPP__PoC__User__Role__IDs.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__User__Role__IDs;
current_location.update_lineno(12461);
/* DIAMETER_Types.ttcn, line 12461 */
const_c__AVP__Code__DCA__3GPP__Announcement__Order.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Announcement__Order;
current_location.update_lineno(12463);
/* DIAMETER_Types.ttcn, line 12463 */
const_c__AVP__Code__CxDx__ETSI__Line__Identifier.vendor__id__ETSI() = AVP__Code__ETSI::avp__code__CxDx__ETSI__Line__Identifier;
current_location.update_lineno(12465);
/* DIAMETER_Types.ttcn, line 12465 */
const_c__AVP__Code__PCC__3GPP__Bearer__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Bearer__Identifier;
current_location.update_lineno(12467);
/* DIAMETER_Types.ttcn, line 12467 */
const_c__AVP__Code__RX__3GPP__Content__Version.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Content__Version;
current_location.update_lineno(12469);
/* DIAMETER_Types.ttcn, line 12469 */
const_c__AVP__Code__DCA__3GPP__Applic__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Applic__ID;
current_location.update_lineno(12471);
/* DIAMETER_Types.ttcn, line 12471 */
const_c__AVP__Code__MIPv4__NONE__MIP__HA__to__FA__MSA.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__HA__to__FA__MSA;
current_location.update_lineno(12473);
/* DIAMETER_Types.ttcn, line 12473 */
const_c__AVP__Code__BASE__NONE__Session__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Session__Id;
current_location.update_lineno(12475);
/* DIAMETER_Types.ttcn, line 12475 */
const_c__AVP__Code__DCA__3GPP__Route__Header__Transmitted.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Route__Header__Transmitted;
current_location.update_lineno(12477);
/* DIAMETER_Types.ttcn, line 12477 */
const_c__AVP__Code__DCA__3GPP__Reporting__Reason.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Reporting__Reason;
current_location.update_lineno(12479);
/* DIAMETER_Types.ttcn, line 12479 */
const_c__AVP__Code__AAA__3GPP__Emergency__Services.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Emergency__Services;
current_location.update_lineno(12481);
/* DIAMETER_Types.ttcn, line 12481 */
const_c__AVP__Code__RX__3GPP__Media__Component__Description.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Media__Component__Description;
current_location.update_lineno(12483);
/* DIAMETER_Types.ttcn, line 12483 */
const_c__AVP__Code__PCC__3GPP__CSG__Information__Reporting.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__CSG__Information__Reporting;
current_location.update_lineno(12485);
/* DIAMETER_Types.ttcn, line 12485 */
const_c__AVP__Code__AAA__3GPP__Measurement__Quantity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Measurement__Quantity;
current_location.update_lineno(12487);
/* DIAMETER_Types.ttcn, line 12487 */
const_c__AVP__Code__S6__3GPP__Location__Information__Configuration.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Location__Information__Configuration;
current_location.update_lineno(12489);
/* DIAMETER_Types.ttcn, line 12489 */
const_c__AVP__Code__PCC__3GPP__Bearer__Usage.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Bearer__Usage;
current_location.update_lineno(12491);
/* DIAMETER_Types.ttcn, line 12491 */
const_c__AVP__Code__DCA__3GPP__Application__provided__Called__Party__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Application__provided__Called__Party__Address;
current_location.update_lineno(12493);
/* DIAMETER_Types.ttcn, line 12493 */
const_c__AVP__Code__DCA__3GPP__Proximity__Alert__Timestamp.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Proximity__Alert__Timestamp;
current_location.update_lineno(12495);
/* DIAMETER_Types.ttcn, line 12495 */
const_c__AVP__Code__PCC__3GPP__Tunnel__Header__Filter.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Tunnel__Header__Filter;
current_location.update_lineno(12497);
/* DIAMETER_Types.ttcn, line 12497 */
const_c__AVP__Code__AAA__3GPP__List__Of__Measurements.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__List__Of__Measurements;
current_location.update_lineno(12499);
/* DIAMETER_Types.ttcn, line 12499 */
const_c__AVP__Code__DCC__NONE__Requested__Service__Unit.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Requested__Service__Unit;
current_location.update_lineno(12501);
/* DIAMETER_Types.ttcn, line 12501 */
const_c__AVP__Code__PCC__3GPP__Default__QoS__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Default__QoS__Name;
current_location.update_lineno(12503);
/* DIAMETER_Types.ttcn, line 12503 */
const_c__AVP__Code__AAA__3GPP__UVA__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__UVA__Flags;
current_location.update_lineno(12505);
/* DIAMETER_Types.ttcn, line 12505 */
const_c__AVP__Code__DCA__3GPP__Expires.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Expires;
current_location.update_lineno(12507);
/* DIAMETER_Types.ttcn, line 12507 */
const_c__AVP__Code__CxDx__3GPP__SAR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__SAR__Flags;
current_location.update_lineno(12509);
/* DIAMETER_Types.ttcn, line 12509 */
const_c__AVP__Code__PCC__3GPP__TDF__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__TDF__Information;
current_location.update_lineno(12511);
/* DIAMETER_Types.ttcn, line 12511 */
const_c__AVP__Code__AAA__3GPP__Group__Service__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Group__Service__Id;
current_location.update_lineno(12513);
/* DIAMETER_Types.ttcn, line 12513 */
const_c__AVP__Code__DCA__3GPP__Recipient__SCCP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Recipient__SCCP__Address;
current_location.update_lineno(12515);
/* DIAMETER_Types.ttcn, line 12515 */
const_c__AVP__Code__DCA__3GPP__Preferred__AoC__Currency.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Preferred__AoC__Currency;
current_location.update_lineno(12517);
/* DIAMETER_Types.ttcn, line 12517 */
const_c__AVP__Code__DNAS__NONE__Framed__Pool.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__Pool;
current_location.update_lineno(12519);
/* DIAMETER_Types.ttcn, line 12519 */
const_c__AVP__Code__DCA__3GPP__Traffic__Data__Volumes.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Traffic__Data__Volumes;
current_location.update_lineno(12521);
/* DIAMETER_Types.ttcn, line 12521 */
const_c__AVP__Code__DCC__NONE__CC__Time.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Time;
current_location.update_lineno(12523);
/* DIAMETER_Types.ttcn, line 12523 */
const_c__AVP__Code__AAA__3GPP__Requested__EUTRAN__Authentication__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Requested__EUTRAN__Authentication__Info;
current_location.update_lineno(12525);
/* DIAMETER_Types.ttcn, line 12525 */
const_c__AVP__Code__DCA__3GPP__Unit__Cost.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Unit__Cost;
current_location.update_lineno(12527);
/* DIAMETER_Types.ttcn, line 12527 */
const_c__AVP__Code__CxDx__3GPP__SIP__Digest__Authenticate.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__SIP__Digest__Authenticate;
current_location.update_lineno(12529);
/* DIAMETER_Types.ttcn, line 12529 */
const_c__AVP__Code__AAA__3GPP__Last__UE__Activity__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Last__UE__Activity__Time;
current_location.update_lineno(12531);
/* DIAMETER_Types.ttcn, line 12531 */
const_c__AVP__Code__AAA__3GPP__Context__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Context__Identifier;
current_location.update_lineno(12533);
/* DIAMETER_Types.ttcn, line 12533 */
const_c__AVP__Code__DCC__NONE__Used__Service__Unit.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Used__Service__Unit;
current_location.update_lineno(12535);
/* DIAMETER_Types.ttcn, line 12535 */
const_c__AVP__Code__MIPv4__NONE__MIP__Reg__Reply.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Reg__Reply;
current_location.update_lineno(12537);
/* DIAMETER_Types.ttcn, line 12537 */
const_c__AVP__Code__BASE__NONE__Auth__Application__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Auth__Application__Id;
current_location.update_lineno(12539);
/* DIAMETER_Types.ttcn, line 12539 */
const_c__AVP__Code__AAA__3GPP__Trace__Reference.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Trace__Reference;
current_location.update_lineno(12541);
/* DIAMETER_Types.ttcn, line 12541 */
const_c__AVP__Code__AAA__3GPP__TWAN__Access__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__TWAN__Access__Info;
current_location.update_lineno(12543);
/* DIAMETER_Types.ttcn, line 12543 */
const_c__AVP__Code__DCA__3GPP__Status__AS__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Status__AS__Code;
current_location.update_lineno(12545);
/* DIAMETER_Types.ttcn, line 12545 */
const_c__AVP__Code__DCA__3GPP__LCS__Client__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Client__Type;
current_location.update_lineno(12547);
/* DIAMETER_Types.ttcn, line 12547 */
const_c__AVP__Code__DNAS__NONE__Framed__Appletalk__Network.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__Appletalk__Network;
current_location.update_lineno(12549);
/* DIAMETER_Types.ttcn, line 12549 */
const_c__AVP__Code__DNAS__NONE__Framed__IPv6__Prefix.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__IPv6__Prefix;
current_location.update_lineno(12551);
/* DIAMETER_Types.ttcn, line 12551 */
const_c__AVP__Code__DCA__3GPP__PoC__Session__Initiation__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__Session__Initiation__Type;
current_location.update_lineno(12553);
/* DIAMETER_Types.ttcn, line 12553 */
const_c__AVP__Code__RX__3GPP__Sharing__Key__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Sharing__Key__UL;
current_location.update_lineno(12555);
/* DIAMETER_Types.ttcn, line 12555 */
const_c__AVP__Code__DCA__3GPP__Content__Size.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Content__Size;
current_location.update_lineno(12557);
/* DIAMETER_Types.ttcn, line 12557 */
const_c__AVP__Code__AAA__3GPP__Access__Network__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Access__Network__Info;
current_location.update_lineno(12559);
/* DIAMETER_Types.ttcn, line 12559 */
const_c__AVP__Code__RX__3GPP__AF__Charging__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__AF__Charging__Identifier;
current_location.update_lineno(12561);
/* DIAMETER_Types.ttcn, line 12561 */
const_c__AVP__Code__S6__3GPP__Monitoring__Event__Report.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Monitoring__Event__Report;
current_location.update_lineno(12563);
/* DIAMETER_Types.ttcn, line 12563 */
const_c__AVP__Code__DCA__3GPP__Service__Specific__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Service__Specific__Type;
current_location.update_lineno(12565);
/* DIAMETER_Types.ttcn, line 12565 */
const_c__AVP__Code__DCA__3GPP__Event.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Event;
current_location.update_lineno(12567);
/* DIAMETER_Types.ttcn, line 12567 */
const_c__AVP__Code__RX__3GPP__Media__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Media__Type;
current_location.update_lineno(12569);
/* DIAMETER_Types.ttcn, line 12569 */
const_c__AVP__Code__PCC__3GPP__Conditional__Policy__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Conditional__Policy__Information;
current_location.update_lineno(12571);
/* DIAMETER_Types.ttcn, line 12571 */
const_c__AVP__Code__BASE__NONE__Firmware__Revision.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Firmware__Revision;
current_location.update_lineno(12573);
/* DIAMETER_Types.ttcn, line 12573 */
const_c__AVP__Code__DCA__3GPP__ProSe__Event__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Event__Type;
current_location.update_lineno(12575);
/* DIAMETER_Types.ttcn, line 12575 */
const_c__AVP__Code__PCC__3GPP__Network__Request__Support.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Network__Request__Support;
current_location.update_lineno(12577);
/* DIAMETER_Types.ttcn, line 12577 */
const_c__AVP__Code__AAA__3GPP__SIPTO__Permission.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SIPTO__Permission;
current_location.update_lineno(12579);
/* DIAMETER_Types.ttcn, line 12579 */
const_c__AVP__Code__DCA__3GPP__Terminating__IOI.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Terminating__IOI;
current_location.update_lineno(12581);
/* DIAMETER_Types.ttcn, line 12581 */
const_c__AVP__Code__RX__3GPP__Extended__Max__Supported__BW__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Extended__Max__Supported__BW__DL;
current_location.update_lineno(12583);
/* DIAMETER_Types.ttcn, line 12583 */
const_c__AVP__Code__PCC__3GPP__UE__Local__IP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__UE__Local__IP__Address;
current_location.update_lineno(12585);
/* DIAMETER_Types.ttcn, line 12585 */
const_c__AVP__Code__DCA__3GPP__SM__Sequence__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SM__Sequence__Number;
current_location.update_lineno(12587);
/* DIAMETER_Types.ttcn, line 12587 */
const_c__AVP__Code__DCA__3GPP__IMS__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__IMS__Information;
current_location.update_lineno(12589);
/* DIAMETER_Types.ttcn, line 12589 */
const_c__AVP__Code__PCC__3GPP__Presence__Reporting__Area__Elements__List.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Presence__Reporting__Area__Elements__List;
current_location.update_lineno(12591);
/* DIAMETER_Types.ttcn, line 12591 */
const_c__AVP__Code__PCC__3GPP__Routing__Rule__Remove.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Routing__Rule__Remove;
current_location.update_lineno(12593);
/* DIAMETER_Types.ttcn, line 12593 */
const_c__AVP__Code__AAA__3GPP__SGs__MME__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SGs__MME__Identity;
current_location.update_lineno(12595);
/* DIAMETER_Types.ttcn, line 12595 */
const_c__AVP__Code__S6__3GPP__Roaming__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Roaming__Information;
current_location.update_lineno(12597);
/* DIAMETER_Types.ttcn, line 12597 */
const_c__AVP__Code__DCA__3GPP__Number__Of__Diversions.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Number__Of__Diversions;
current_location.update_lineno(12599);
/* DIAMETER_Types.ttcn, line 12599 */
const_c__AVP__Code__DCA__3GPP__Coverage__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Coverage__Info;
current_location.update_lineno(12601);
/* DIAMETER_Types.ttcn, line 12601 */
const_c__AVP__Code__CxDx__3GPP__SIP__Authentication__Scheme.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__SIP__Authentication__Scheme;
current_location.update_lineno(12603);
/* DIAMETER_Types.ttcn, line 12603 */
const_c__AVP__Code__AAA__3GPP__Event__Threshold__RSRP.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Event__Threshold__RSRP;
current_location.update_lineno(12605);
/* DIAMETER_Types.ttcn, line 12605 */
const_c__AVP__Code__CxDx__3GPP__User__Authorization__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__User__Authorization__Type;
current_location.update_lineno(12607);
/* DIAMETER_Types.ttcn, line 12607 */
const_c__AVP__Code__AAA__3GPP__PLMN__Client.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__PLMN__Client;
current_location.update_lineno(12609);
/* DIAMETER_Types.ttcn, line 12609 */
const_c__AVP__Code__AAA__3GPP__Re__Synchronization__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Re__Synchronization__Info;
current_location.update_lineno(12611);
/* DIAMETER_Types.ttcn, line 12611 */
const_c__AVP__Code__BASE__NONE__Auth__Grace__Period.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Auth__Grace__Period;
current_location.update_lineno(12613);
/* DIAMETER_Types.ttcn, line 12613 */
const_c__AVP__Code__DCA__3GPP__User__CSG__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__User__CSG__Information;
current_location.update_lineno(12615);
/* DIAMETER_Types.ttcn, line 12615 */
const_c__AVP__Code__DCA__3GPP__SM__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SM__Status;
current_location.update_lineno(12617);
/* DIAMETER_Types.ttcn, line 12617 */
const_c__AVP__Code__DCA__3GPP__IP__Realm__Default__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__IP__Realm__Default__Indication;
current_location.update_lineno(12619);
/* DIAMETER_Types.ttcn, line 12619 */
const_c__AVP__Code__AAA__3GPP__RAND.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__RAND;
current_location.update_lineno(12621);
/* DIAMETER_Types.ttcn, line 12621 */
const_c__AVP__Code__AAA__3GPP__Trace__Depth.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Trace__Depth;
current_location.update_lineno(12623);
/* DIAMETER_Types.ttcn, line 12623 */
const_c__AVP__Code__MIPv4__NONE__MIP__MN__to__FA__MSA.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__MN__to__FA__MSA;
current_location.update_lineno(12625);
/* DIAMETER_Types.ttcn, line 12625 */
const_c__AVP__Code__AAA__3GPP__SGSN__User__State.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SGSN__User__State;
current_location.update_lineno(12627);
/* DIAMETER_Types.ttcn, line 12627 */
const_c__AVP__Code__AAA__3GPP__APN__OI__Replacement.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__APN__OI__Replacement;
current_location.update_lineno(12629);
/* DIAMETER_Types.ttcn, line 12629 */
const_c__AVP__Code__DCA__3GPP__Alternate__Charged__Party__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Alternate__Charged__Party__Address;
current_location.update_lineno(12631);
/* DIAMETER_Types.ttcn, line 12631 */
const_c__AVP__Code__DCA__3GPP__APN__Rate__Control.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__APN__Rate__Control;
current_location.update_lineno(12633);
/* DIAMETER_Types.ttcn, line 12633 */
const_c__AVP__Code__BASE__NONE__Re__Auth__Request__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Re__Auth__Request__Type;
current_location.update_lineno(12635);
/* DIAMETER_Types.ttcn, line 12635 */
const_c__AVP__Code__DCA__3GPP__Relationship__Mode.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Relationship__Mode;
current_location.update_lineno(12637);
/* DIAMETER_Types.ttcn, line 12637 */
const_c__AVP__Code__S6__3GPP__External__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__External__Identifier;
current_location.update_lineno(12639);
/* DIAMETER_Types.ttcn, line 12639 */
const_c__AVP__Code__DCA__3GPP__Positioning__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Positioning__Data;
current_location.update_lineno(12641);
/* DIAMETER_Types.ttcn, line 12641 */
const_c__AVP__Code__DCC__NONE__Redirect__Address__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Redirect__Address__Type;
current_location.update_lineno(12643);
/* DIAMETER_Types.ttcn, line 12643 */
const_c__AVP__Code__MIPv6__NONE__MIP__MN__HA__MSA.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__MIP__MN__HA__MSA;
current_location.update_lineno(12645);
/* DIAMETER_Types.ttcn, line 12645 */
const_c__AVP__Code__DCA__3GPP__Monitoring__UE__HPLMN__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Monitoring__UE__HPLMN__Identifier;
current_location.update_lineno(12647);
/* DIAMETER_Types.ttcn, line 12647 */
const_c__AVP__Code__PCC__3GPP__TFT__Filter.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__TFT__Filter;
current_location.update_lineno(12649);
/* DIAMETER_Types.ttcn, line 12649 */
const_c__AVP__Code__RX__3GPP__Max__Supported__Bandwidth__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Max__Supported__Bandwidth__UL;
current_location.update_lineno(12651);
/* DIAMETER_Types.ttcn, line 12651 */
const_c__AVP__Code__S6__3GPP__Loss__Of__Connectivity__Reason.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Loss__Of__Connectivity__Reason;
current_location.update_lineno(12653);
/* DIAMETER_Types.ttcn, line 12653 */
const_c__AVP__Code__DNAS__NONE__Tunnel__Medium__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunnel__Medium__Type;
current_location.update_lineno(12655);
/* DIAMETER_Types.ttcn, line 12655 */
const_c__AVP__Code__DCA__3GPP__Originator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Originator;
current_location.update_lineno(12657);
/* DIAMETER_Types.ttcn, line 12657 */
const_c__AVP__Code__DCC__NONE__User__Equipment__Info__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__User__Equipment__Info__Type;
current_location.update_lineno(12659);
/* DIAMETER_Types.ttcn, line 12659 */
const_c__AVP__Code__RX__3GPP__Flow__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Flow__Number;
current_location.update_lineno(12661);
/* DIAMETER_Types.ttcn, line 12661 */
const_c__AVP__Code__MIPv4__NONE__MIP__Home__Agent__Address.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Home__Agent__Address;
current_location.update_lineno(12663);
/* DIAMETER_Types.ttcn, line 12663 */
const_c__AVP__Code__PCC__3GPP__Resource__Allocation__Notification.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Resource__Allocation__Notification;
current_location.update_lineno(12665);
/* DIAMETER_Types.ttcn, line 12665 */
const_c__AVP__Code__DCA__3GPP__Basic__Service__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Basic__Service__Code;
current_location.update_lineno(12667);
/* DIAMETER_Types.ttcn, line 12667 */
const_c__AVP__Code__S6__3GPP__Monitoring__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Monitoring__Type;
current_location.update_lineno(12669);
/* DIAMETER_Types.ttcn, line 12669 */
const_c__AVP__Code__DCA__3GPP__Role__Of__Node.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Role__Of__Node;
current_location.update_lineno(12671);
/* DIAMETER_Types.ttcn, line 12671 */
const_c__AVP__Code__PCC__3GPP__Default__Bearer__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Default__Bearer__Indication;
current_location.update_lineno(12673);
/* DIAMETER_Types.ttcn, line 12673 */
const_c__AVP__Code__DCA__3GPP__ProSe__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Information;
current_location.update_lineno(12675);
/* DIAMETER_Types.ttcn, line 12675 */
const_c__AVP__Code__PCC__3GPP__QoS__Class__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__QoS__Class__Identifier;
current_location.update_lineno(12677);
/* DIAMETER_Types.ttcn, line 12677 */
const_c__AVP__Code__AAA__3GPP__VPLMN__LIPA__Allowed.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__VPLMN__LIPA__Allowed;
current_location.update_lineno(12679);
/* DIAMETER_Types.ttcn, line 12679 */
const_c__AVP__Code__PCC__3GPP__Mute__Notification.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Mute__Notification;
current_location.update_lineno(12681);
/* DIAMETER_Types.ttcn, line 12681 */
const_c__AVP__Code__CxDx__3GPP__SIP__Authentication__Context.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__SIP__Authentication__Context;
current_location.update_lineno(12683);
/* DIAMETER_Types.ttcn, line 12683 */
const_c__AVP__Code__MIPv6__NONE__QoS__Resources.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__QoS__Resources;
current_location.update_lineno(12685);
/* DIAMETER_Types.ttcn, line 12685 */
const_c__AVP__Code__AAA__3GPP__Logging__Duration.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Logging__Duration;
current_location.update_lineno(12687);
/* DIAMETER_Types.ttcn, line 12687 */
const_c__AVP__Code__DCC__NONE__Service__Parameter__Value.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Service__Parameter__Value;
current_location.update_lineno(12689);
/* DIAMETER_Types.ttcn, line 12689 */
const_c__AVP__Code__CxDx__3GPP__Associated__Registered__Identities.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Associated__Registered__Identities;
current_location.update_lineno(12691);
/* DIAMETER_Types.ttcn, line 12691 */
const_c__AVP__Code__PCC__3GPP__Routing__IP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Routing__IP__Address;
current_location.update_lineno(12693);
/* DIAMETER_Types.ttcn, line 12693 */
const_c__AVP__Code__AAA__3GPP__WLAN__offloadability__EUTRAN.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__WLAN__offloadability__EUTRAN;
current_location.update_lineno(12695);
/* DIAMETER_Types.ttcn, line 12695 */
const_c__AVP__Code__DCA__3GPP__MBMS__GW__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MBMS__GW__Address;
current_location.update_lineno(12697);
/* DIAMETER_Types.ttcn, line 12697 */
const_c__AVP__Code__DCA__3GPP__Destination__Interface.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Destination__Interface;
current_location.update_lineno(12699);
/* DIAMETER_Types.ttcn, line 12699 */
const_c__AVP__Code__DCA__3GPP__IMS__Emergency__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__IMS__Emergency__Indicator;
current_location.update_lineno(12701);
/* DIAMETER_Types.ttcn, line 12701 */
const_c__AVP__Code__DCA__3GPP__Change__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Change__Time;
current_location.update_lineno(12703);
/* DIAMETER_Types.ttcn, line 12703 */
const_c__AVP__Code__AAA__3GPP__KASME.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__KASME;
current_location.update_lineno(12705);
/* DIAMETER_Types.ttcn, line 12705 */
const_c__AVP__Code__MIPv4__NONE__MIP__Session__Key.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Session__Key;
current_location.update_lineno(12707);
/* DIAMETER_Types.ttcn, line 12707 */
const_c__AVP__Code__DCA__3GPP__AoC__Cost__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__AoC__Cost__Information;
current_location.update_lineno(12709);
/* DIAMETER_Types.ttcn, line 12709 */
const_c__AVP__Code__GI__3GPP__3GPP__User__Location__Info__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__User__Location__Info__Time;
current_location.update_lineno(12711);
/* DIAMETER_Types.ttcn, line 12711 */
const_c__AVP__Code__AAA__3GPP__Teleservice__List.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Teleservice__List;
current_location.update_lineno(12713);
/* DIAMETER_Types.ttcn, line 12713 */
const_c__AVP__Code__AAA__3GPP__UTRAN__Vector.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__UTRAN__Vector;
current_location.update_lineno(12715);
/* DIAMETER_Types.ttcn, line 12715 */
const_c__AVP__Code__AAA__3GPP__Non__3GPP__IP__Access__APN.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Non__3GPP__IP__Access__APN;
current_location.update_lineno(12717);
/* DIAMETER_Types.ttcn, line 12717 */
const_c__AVP__Code__DCA__3GPP__Monitoring__Event__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Monitoring__Event__Information;
current_location.update_lineno(12719);
/* DIAMETER_Types.ttcn, line 12719 */
const_c__AVP__Code__DCC__NONE__Tariff__Time__Change.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Tariff__Time__Change;
current_location.update_lineno(12721);
/* DIAMETER_Types.ttcn, line 12721 */
const_c__AVP__Code__GI__3GPP__3GPP__NSAPI.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__NSAPI;
current_location.update_lineno(12723);
/* DIAMETER_Types.ttcn, line 12723 */
const_c__AVP__Code__DCA__3GPP__LCS__Client__Dialed__By__MS.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Client__Dialed__By__MS;
current_location.update_lineno(12725);
/* DIAMETER_Types.ttcn, line 12725 */
const_c__AVP__Code__GI__3GPP__3GPP__CG__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__CG__Address;
current_location.update_lineno(12727);
/* DIAMETER_Types.ttcn, line 12727 */
const_c__AVP__Code__DCA__3GPP__Envelope__Start__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Envelope__Start__Time;
current_location.update_lineno(12729);
/* DIAMETER_Types.ttcn, line 12729 */
const_c__AVP__Code__RX__3GPP__Application__Service__Provider__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Application__Service__Provider__Identity;
current_location.update_lineno(12731);
/* DIAMETER_Types.ttcn, line 12731 */
const_c__AVP__Code__S6__3GPP__NIDD__Authorization__Request.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__NIDD__Authorization__Request;
current_location.update_lineno(12733);
/* DIAMETER_Types.ttcn, line 12733 */
const_c__AVP__Code__DCA__3GPP__Received__Talk__Burst__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Received__Talk__Burst__Time;
current_location.update_lineno(12735);
/* DIAMETER_Types.ttcn, line 12735 */
const_c__AVP__Code__DCA__3GPP__Incoming__Trunk__Group__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Incoming__Trunk__Group__Id;
current_location.update_lineno(12737);
/* DIAMETER_Types.ttcn, line 12737 */
const_c__AVP__Code__AAA__3GPP__AAA__Failure__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__AAA__Failure__Indication;
current_location.update_lineno(12739);
/* DIAMETER_Types.ttcn, line 12739 */
const_c__AVP__Code__DCA__3GPP__Rate__Control__Max__Message__Size.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Rate__Control__Max__Message__Size;
current_location.update_lineno(12741);
/* DIAMETER_Types.ttcn, line 12741 */
const_c__AVP__Code__PCC__3GPP__QoS__Rule__Install.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__QoS__Rule__Install;
current_location.update_lineno(12743);
/* DIAMETER_Types.ttcn, line 12743 */
const_c__AVP__Code__S6__3GPP__Periodic__Communication__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Periodic__Communication__Indicator;
current_location.update_lineno(12745);
/* DIAMETER_Types.ttcn, line 12745 */
const_c__AVP__Code__DCA__3GPP__Service__Specific__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Service__Specific__Info;
current_location.update_lineno(12747);
/* DIAMETER_Types.ttcn, line 12747 */
const_c__AVP__Code__RX__3GPP__Flow__Usage.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Flow__Usage;
current_location.update_lineno(12749);
/* DIAMETER_Types.ttcn, line 12749 */
const_c__AVP__Code__PCC__3GPP__RAN__Rule__Support.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__RAN__Rule__Support;
current_location.update_lineno(12751);
/* DIAMETER_Types.ttcn, line 12751 */
const_c__AVP__Code__DNAS__NONE__Tunnel__Password.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunnel__Password;
current_location.update_lineno(12753);
/* DIAMETER_Types.ttcn, line 12753 */
const_c__AVP__Code__DCA__3GPP__PC3__EPC__Control__Protocol__Cause.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PC3__EPC__Control__Protocol__Cause;
current_location.update_lineno(12755);
/* DIAMETER_Types.ttcn, line 12755 */
const_c__AVP__Code__S6__3GPP__Monitoring__Duration.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Monitoring__Duration;
current_location.update_lineno(12757);
/* DIAMETER_Types.ttcn, line 12757 */
const_c__AVP__Code__PCC__3GPP__QoS__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__QoS__Information;
current_location.update_lineno(12759);
/* DIAMETER_Types.ttcn, line 12759 */
const_c__AVP__Code__AAA__3GPP__Routing__Area__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Routing__Area__Identity;
current_location.update_lineno(12761);
/* DIAMETER_Types.ttcn, line 12761 */
const_c__AVP__Code__DCA__3GPP__Called__Party__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Called__Party__Address;
current_location.update_lineno(12763);
/* DIAMETER_Types.ttcn, line 12763 */
const_c__AVP__Code__RX__3GPP__Service__Authorization__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Service__Authorization__Info;
current_location.update_lineno(12765);
/* DIAMETER_Types.ttcn, line 12765 */
const_c__AVP__Code__DNAS__NONE__Tunneling.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunneling;
current_location.update_lineno(12767);
/* DIAMETER_Types.ttcn, line 12767 */
const_c__AVP__Code__DCC__NONE__User__Equipment__Info__Value.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__User__Equipment__Info__Value;
current_location.update_lineno(12769);
/* DIAMETER_Types.ttcn, line 12769 */
const_c__AVP__Code__MIPv4__NONE__MIP__Auth__Input__Data__Length.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Auth__Input__Data__Length;
current_location.update_lineno(12771);
/* DIAMETER_Types.ttcn, line 12771 */
const_c__AVP__Code__AAA__3GPP__eDRX__Cycle__Length.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__eDRX__Cycle__Length;
current_location.update_lineno(12773);
/* DIAMETER_Types.ttcn, line 12773 */
const_c__AVP__Code__BASE__NONE__Multi__Round__Time__Out.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Multi__Round__Time__Out;
current_location.update_lineno(12775);
/* DIAMETER_Types.ttcn, line 12775 */
const_c__AVP__Code__S6__3GPP__Group__Monitoring__Event__Report__Item.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Group__Monitoring__Event__Report__Item;
current_location.update_lineno(12777);
/* DIAMETER_Types.ttcn, line 12777 */
const_c__AVP__Code__PCC__3GPP__Rule__Failure__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Rule__Failure__Code;
current_location.update_lineno(12779);
/* DIAMETER_Types.ttcn, line 12779 */
const_c__AVP__Code__AAA__3GPP__Ext__PDP__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Ext__PDP__Type;
current_location.update_lineno(12781);
/* DIAMETER_Types.ttcn, line 12781 */
const_c__AVP__Code__DCA__3GPP__Time__Quota__Threshold.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Time__Quota__Threshold;
current_location.update_lineno(12783);
/* DIAMETER_Types.ttcn, line 12783 */
const_c__AVP__Code__PCC__3GPP__User__Location__Info__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__User__Location__Info__Time;
current_location.update_lineno(12785);
/* DIAMETER_Types.ttcn, line 12785 */
const_c__AVP__Code__PCC__3GPP__Usage__Monitoring__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Usage__Monitoring__Information;
current_location.update_lineno(12787);
/* DIAMETER_Types.ttcn, line 12787 */
const_c__AVP__Code__AAA__3GPP__Measurement__Period__LTE.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Measurement__Period__LTE;
current_location.update_lineno(12789);
/* DIAMETER_Types.ttcn, line 12789 */
const_c__AVP__Code__PCC__3GPP__Extended__APN__AMBR__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Extended__APN__AMBR__DL;
current_location.update_lineno(12791);
/* DIAMETER_Types.ttcn, line 12791 */
const_c__AVP__Code__BASE__NONE__Experimental__Result__Code.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Experimental__Result__Code;
current_location.update_lineno(12793);
/* DIAMETER_Types.ttcn, line 12793 */
const_c__AVP__Code__CxDx__3GPP__Session__Priority.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Session__Priority;
current_location.update_lineno(12795);
/* DIAMETER_Types.ttcn, line 12795 */
const_c__AVP__Code__DCA__3GPP__Recipient__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Recipient__Info;
current_location.update_lineno(12797);
/* DIAMETER_Types.ttcn, line 12797 */
const_c__AVP__Code__DCA__3GPP__AoC__Format.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__AoC__Format;
current_location.update_lineno(12799);
/* DIAMETER_Types.ttcn, line 12799 */
const_c__AVP__Code__DCA__3GPP__Start__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Start__Time;
current_location.update_lineno(12801);
/* DIAMETER_Types.ttcn, line 12801 */
const_c__AVP__Code__CxDx__3GPP__Deregistration__Reason.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Deregistration__Reason;
current_location.update_lineno(12803);
/* DIAMETER_Types.ttcn, line 12803 */
const_c__AVP__Code__AAA__3GPP__GMLC__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__GMLC__Number;
current_location.update_lineno(12805);
/* DIAMETER_Types.ttcn, line 12805 */
const_c__AVP__Code__AAA__3GPP__Software__Version.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Software__Version;
current_location.update_lineno(12807);
/* DIAMETER_Types.ttcn, line 12807 */
const_c__AVP__Code__DNAS__NONE__Callback__Number.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Callback__Number;
current_location.update_lineno(12809);
/* DIAMETER_Types.ttcn, line 12809 */
const_c__AVP__Code__DNAS__NONE__Configuration__Token.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Configuration__Token;
current_location.update_lineno(12811);
/* DIAMETER_Types.ttcn, line 12811 */
const_c__AVP__Code__DCA__3GPP__Interface__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Interface__Type;
current_location.update_lineno(12813);
/* DIAMETER_Types.ttcn, line 12813 */
const_c__AVP__Code__MIPv4__NONE__MIP__Originating__Foreign__AAA.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Originating__Foreign__AAA;
current_location.update_lineno(12815);
/* DIAMETER_Types.ttcn, line 12815 */
const_c__AVP__Code__AAA__3GPP__Expiration__Date.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Expiration__Date;
current_location.update_lineno(12817);
/* DIAMETER_Types.ttcn, line 12817 */
const_c__AVP__Code__BASE__NONE__Error__Message.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Error__Message;
current_location.update_lineno(12819);
/* DIAMETER_Types.ttcn, line 12819 */
const_c__AVP__Code__AAA__3GPP__SRES.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SRES;
current_location.update_lineno(12821);
/* DIAMETER_Types.ttcn, line 12821 */
const_c__AVP__Code__DCA__3GPP__DRM__Content.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__DRM__Content;
current_location.update_lineno(12823);
/* DIAMETER_Types.ttcn, line 12823 */
const_c__AVP__Code__AAA__3GPP__Item__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Item__Number;
current_location.update_lineno(12825);
/* DIAMETER_Types.ttcn, line 12825 */
const_c__AVP__Code__DNAS__NONE__NAS__Port__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__NAS__Port__Type;
current_location.update_lineno(12827);
/* DIAMETER_Types.ttcn, line 12827 */
const_c__AVP__Code__AAA__3GPP__ERP__Authorization.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__ERP__Authorization;
current_location.update_lineno(12829);
/* DIAMETER_Types.ttcn, line 12829 */
const_c__AVP__Code__DCC__NONE__Multiple__Services__Indicator.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Multiple__Services__Indicator;
current_location.update_lineno(12831);
/* DIAMETER_Types.ttcn, line 12831 */
const_c__AVP__Code__DCA__3GPP__Early__Media__Description.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Early__Media__Description;
current_location.update_lineno(12833);
/* DIAMETER_Types.ttcn, line 12833 */
const_c__AVP__Code__AAA__3GPP__MIP__FA__RK.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MIP__FA__RK;
current_location.update_lineno(12835);
/* DIAMETER_Types.ttcn, line 12835 */
const_c__AVP__Code__DCA__3GPP__Related__Change__Condition__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Related__Change__Condition__Information;
current_location.update_lineno(12837);
/* DIAMETER_Types.ttcn, line 12837 */
const_c__AVP__Code__DNAS__NONE__Framed__Protocol.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__Protocol;
current_location.update_lineno(12839);
/* DIAMETER_Types.ttcn, line 12839 */
const_c__AVP__Code__S6__3GPP__Service__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Service__ID;
current_location.update_lineno(12841);
/* DIAMETER_Types.ttcn, line 12841 */
const_c__AVP__Code__DCA__3GPP__LCS__Format__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Format__Indicator;
current_location.update_lineno(12843);
/* DIAMETER_Types.ttcn, line 12843 */
const_c__AVP__Code__GI__3GPP__3GPP__IMSI__MCC__MNC.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__IMSI__MCC__MNC;
current_location.update_lineno(12845);
/* DIAMETER_Types.ttcn, line 12845 */
const_c__AVP__Code__RX__3GPP__Abort__Cause.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Abort__Cause;
current_location.update_lineno(12847);
/* DIAMETER_Types.ttcn, line 12847 */
const_c__AVP__Code__DCA__3GPP__ISUP__Cause__Location.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ISUP__Cause__Location;
current_location.update_lineno(12849);
/* DIAMETER_Types.ttcn, line 12849 */
const_c__AVP__Code__PCC__3GPP__Charging__Rule__Base__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Charging__Rule__Base__Name;
current_location.update_lineno(12851);
/* DIAMETER_Types.ttcn, line 12851 */
const_c__AVP__Code__RX__3GPP__Required__Access__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Required__Access__Info;
current_location.update_lineno(12853);
/* DIAMETER_Types.ttcn, line 12853 */
const_c__AVP__Code__PCC__3GPP__TDF__Destination__Realm.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__TDF__Destination__Realm;
current_location.update_lineno(12855);
/* DIAMETER_Types.ttcn, line 12855 */
const_c__AVP__Code__S6__3GPP__S6t__HSS__Cause.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__S6t__HSS__Cause;
current_location.update_lineno(12857);
/* DIAMETER_Types.ttcn, line 12857 */
const_c__AVP__Code__DCA__3GPP__Media__Initiator__Party.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Media__Initiator__Party;
current_location.update_lineno(12859);
/* DIAMETER_Types.ttcn, line 12859 */
const_c__AVP__Code__DCA__3GPP__Associated__URI.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Associated__URI;
current_location.update_lineno(12861);
/* DIAMETER_Types.ttcn, line 12861 */
const_c__AVP__Code__RX__3GPP__AF__Requested__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__AF__Requested__Data;
current_location.update_lineno(12863);
/* DIAMETER_Types.ttcn, line 12863 */
const_c__AVP__Code__PCC__3GPP__QoS__Rule__Report.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__QoS__Rule__Report;
current_location.update_lineno(12865);
/* DIAMETER_Types.ttcn, line 12865 */
const_c__AVP__Code__DNAS__NONE__Filter__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Filter__Id;
current_location.update_lineno(12867);
/* DIAMETER_Types.ttcn, line 12867 */
const_c__AVP__Code__DNAS__NONE__ARAP__Password.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__ARAP__Password;
current_location.update_lineno(12869);
/* DIAMETER_Types.ttcn, line 12869 */
const_c__AVP__Code__DCA__3GPP__Route__Header__Received.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Route__Header__Received;
current_location.update_lineno(12871);
/* DIAMETER_Types.ttcn, line 12871 */
const_c__AVP__Code__S6__3GPP__Stationary__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Stationary__Indication;
current_location.update_lineno(12873);
/* DIAMETER_Types.ttcn, line 12873 */
const_c__AVP__Code__DNAS__NONE__CHAP__Response.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__CHAP__Response;
current_location.update_lineno(12875);
/* DIAMETER_Types.ttcn, line 12875 */
const_c__AVP__Code__PCC__3GPP__Traffic__Steering__Policy__Identifier__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Traffic__Steering__Policy__Identifier__DL;
current_location.update_lineno(12877);
/* DIAMETER_Types.ttcn, line 12877 */
const_c__AVP__Code__DCA__3GPP__Usage__Information__Report__Sequence__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Usage__Information__Report__Sequence__Number;
current_location.update_lineno(12879);
/* DIAMETER_Types.ttcn, line 12879 */
const_c__AVP__Code__AAA__3GPP__Geodetic__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Geodetic__Information;
current_location.update_lineno(12881);
/* DIAMETER_Types.ttcn, line 12881 */
const_c__AVP__Code__PCC__3GPP__Extended__GBR__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Extended__GBR__UL;
current_location.update_lineno(12883);
/* DIAMETER_Types.ttcn, line 12883 */
const_c__AVP__Code__AAA__3GPP__MBSFN__Area__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MBSFN__Area__ID;
current_location.update_lineno(12885);
/* DIAMETER_Types.ttcn, line 12885 */
const_c__AVP__Code__CxDx__3GPP__Server__Capabilities.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Server__Capabilities;
current_location.update_lineno(12887);
/* DIAMETER_Types.ttcn, line 12887 */
const_c__AVP__Code__AAA__3GPP__Area__Scope.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Area__Scope;
current_location.update_lineno(12889);
/* DIAMETER_Types.ttcn, line 12889 */
const_c__AVP__Code__MIPv4__NONE__Accounting__Input__Packets.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__Accounting__Input__Packets;
current_location.update_lineno(12891);
/* DIAMETER_Types.ttcn, line 12891 */
const_c__AVP__Code__DCA__3GPP__SGW__Change.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SGW__Change;
current_location.update_lineno(12893);
/* DIAMETER_Types.ttcn, line 12893 */
const_c__AVP__Code__CxDx__3GPP__SCSCF__Restoration__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__SCSCF__Restoration__Info;
current_location.update_lineno(12895);
/* DIAMETER_Types.ttcn, line 12895 */
const_c__AVP__Code__CxDx__3GPP__Initial__CSeq__Sequence__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Initial__CSeq__Sequence__Number;
current_location.update_lineno(12897);
/* DIAMETER_Types.ttcn, line 12897 */
const_c__AVP__Code__DCA__3GPP__AoC__Subscription__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__AoC__Subscription__Information;
current_location.update_lineno(12899);
/* DIAMETER_Types.ttcn, line 12899 */
const_c__AVP__Code__AAA__3GPP__PUA__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__PUA__Flags;
current_location.update_lineno(12901);
/* DIAMETER_Types.ttcn, line 12901 */
const_c__AVP__Code__DNAS__NONE__Callback__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Callback__Id;
current_location.update_lineno(12903);
/* DIAMETER_Types.ttcn, line 12903 */
const_c__AVP__Code__DCA__3GPP__Time__Usage.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Time__Usage;
current_location.update_lineno(12905);
/* DIAMETER_Types.ttcn, line 12905 */
const_c__AVP__Code__CxDx__3GPP__Primary__Event__Charging__Function__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Primary__Event__Charging__Function__Name;
current_location.update_lineno(12907);
/* DIAMETER_Types.ttcn, line 12907 */
const_c__AVP__Code__DCC__NONE__CC__Output__Octets.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Output__Octets;
current_location.update_lineno(12909);
/* DIAMETER_Types.ttcn, line 12909 */
const_c__AVP__Code__GI__3GPP__3GPP__User__Location__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__User__Location__Info;
current_location.update_lineno(12911);
/* DIAMETER_Types.ttcn, line 12911 */
const_c__AVP__Code__AAA__3GPP__Notification__To__UE__User.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Notification__To__UE__User;
current_location.update_lineno(12913);
/* DIAMETER_Types.ttcn, line 12913 */
const_c__AVP__Code__AAA__3GPP__Visited__PLMN__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Visited__PLMN__Id;
current_location.update_lineno(12915);
/* DIAMETER_Types.ttcn, line 12915 */
const_c__AVP__Code__AAA__3GPP__Homogeneous__Support__of__IMS__Voice__Over__PS__Sessions.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Homogeneous__Support__of__IMS__Voice__Over__PS__Sessions;
current_location.update_lineno(12917);
/* DIAMETER_Types.ttcn, line 12917 */
const_c__AVP__Code__DCA__3GPP__Participant__Group.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Participant__Group;
current_location.update_lineno(12919);
/* DIAMETER_Types.ttcn, line 12919 */
const_c__AVP__Code__DCA__3GPP__Play__Alternative.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Play__Alternative;
current_location.update_lineno(12921);
/* DIAMETER_Types.ttcn, line 12921 */
const_c__AVP__Code__DCA__3GPP__MBMS__User__Service__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MBMS__User__Service__Type;
current_location.update_lineno(12923);
/* DIAMETER_Types.ttcn, line 12923 */
const_c__AVP__Code__DCA__3GPP__Transit__IOI__List.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Transit__IOI__List;
current_location.update_lineno(12925);
/* DIAMETER_Types.ttcn, line 12925 */
const_c__AVP__Code__RX__3GPP__Codec__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Codec__Data;
current_location.update_lineno(12927);
/* DIAMETER_Types.ttcn, line 12927 */
const_c__AVP__Code__S6__3GPP__Monitoring__Event__Config__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Monitoring__Event__Config__Status;
current_location.update_lineno(12929);
/* DIAMETER_Types.ttcn, line 12929 */
const_c__AVP__Code__DCA__3GPP__SDP__Media__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SDP__Media__Name;
current_location.update_lineno(12931);
/* DIAMETER_Types.ttcn, line 12931 */
const_c__AVP__Code__DCA__3GPP__AF__Correlation__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__AF__Correlation__Information;
current_location.update_lineno(12933);
/* DIAMETER_Types.ttcn, line 12933 */
const_c__AVP__Code__DCC__NONE__Cost__Information.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Cost__Information;
current_location.update_lineno(12935);
/* DIAMETER_Types.ttcn, line 12935 */
const_c__AVP__Code__DCA__3GPP__Serving__Node__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Serving__Node__Identity;
current_location.update_lineno(12937);
/* DIAMETER_Types.ttcn, line 12937 */
const_c__AVP__Code__BASE__NONE__Error__Reporting__Host.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Error__Reporting__Host;
current_location.update_lineno(12939);
/* DIAMETER_Types.ttcn, line 12939 */
const_c__AVP__Code__DCA__3GPP__Radio__Frequency.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Radio__Frequency;
current_location.update_lineno(12941);
/* DIAMETER_Types.ttcn, line 12941 */
const_c__AVP__Code__PCC__3GPP__Rule__Activation__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Rule__Activation__Time;
current_location.update_lineno(12943);
/* DIAMETER_Types.ttcn, line 12943 */
const_c__AVP__Code__S6__3GPP__Service__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Service__Data;
current_location.update_lineno(12945);
/* DIAMETER_Types.ttcn, line 12945 */
const_c__AVP__Code__RX__3GPP__AF__Application__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__AF__Application__Identifier;
current_location.update_lineno(12947);
/* DIAMETER_Types.ttcn, line 12947 */
const_c__AVP__Code__PCC__3GPP__NetLoc__Access__Support.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__NetLoc__Access__Support;
current_location.update_lineno(12949);
/* DIAMETER_Types.ttcn, line 12949 */
const_c__AVP__Code__DCA__3GPP__Announcing__UE__VPLMN__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Announcing__UE__VPLMN__Identifier;
current_location.update_lineno(12951);
/* DIAMETER_Types.ttcn, line 12951 */
const_c__AVP__Code__S6__3GPP__Monitoring__Event__Configuration.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Monitoring__Event__Configuration;
current_location.update_lineno(12953);
/* DIAMETER_Types.ttcn, line 12953 */
const_c__AVP__Code__PCC__3GPP__Offline.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Offline;
current_location.update_lineno(12955);
/* DIAMETER_Types.ttcn, line 12955 */
const_c__AVP__Code__DCA__3GPP__SIP__Method.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SIP__Method;
current_location.update_lineno(12957);
/* DIAMETER_Types.ttcn, line 12957 */
const_c__AVP__Code__PCC__3GPP__ADC__Rule__Definition.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__ADC__Rule__Definition;
current_location.update_lineno(12959);
/* DIAMETER_Types.ttcn, line 12959 */
const_c__AVP__Code__AAA__3GPP__Additional__Context__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Additional__Context__ID;
current_location.update_lineno(12961);
/* DIAMETER_Types.ttcn, line 12961 */
const_c__AVP__Code__DNAS__NONE__Login__Service.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Login__Service;
current_location.update_lineno(12963);
/* DIAMETER_Types.ttcn, line 12963 */
const_c__AVP__Code__DNAS__NONE__ARAP__Security__Data.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__ARAP__Security__Data;
current_location.update_lineno(12965);
/* DIAMETER_Types.ttcn, line 12965 */
const_c__AVP__Code__S6__3GPP__Allowed__PLMN__List.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Allowed__PLMN__List;
current_location.update_lineno(12967);
/* DIAMETER_Types.ttcn, line 12967 */
const_c__AVP__Code__PCC__3GPP__Bearer__Control__Mode.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Bearer__Control__Mode;
current_location.update_lineno(12969);
/* DIAMETER_Types.ttcn, line 12969 */
const_c__AVP__Code__AAA__3GPP__Active__APN.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Active__APN;
current_location.update_lineno(12971);
/* DIAMETER_Types.ttcn, line 12971 */
const_c__AVP__Code__PCC__3GPP__HeNB__Local__IP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__HeNB__Local__IP__Address;
current_location.update_lineno(12973);
/* DIAMETER_Types.ttcn, line 12973 */
const_c__AVP__Code__PCC__3GPP__Packet__Filter__Content.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Packet__Filter__Content;
current_location.update_lineno(12975);
/* DIAMETER_Types.ttcn, line 12975 */
const_c__AVP__Code__AAA__3GPP__SMS__Register__Request.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SMS__Register__Request;
current_location.update_lineno(12977);
/* DIAMETER_Types.ttcn, line 12977 */
const_c__AVP__Code__CxDx__3GPP__Subscription__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Subscription__Info;
current_location.update_lineno(12979);
/* DIAMETER_Types.ttcn, line 12979 */
const_c__AVP__Code__DCA__3GPP__SIP__Response__Timestamp__Fraction.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SIP__Response__Timestamp__Fraction;
current_location.update_lineno(12981);
/* DIAMETER_Types.ttcn, line 12981 */
const_c__AVP__Code__DCA__3GPP__Client__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Client__Address;
current_location.update_lineno(12983);
/* DIAMETER_Types.ttcn, line 12983 */
const_c__AVP__Code__AAA__3GPP__APN__Configuration.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__APN__Configuration;
current_location.update_lineno(12985);
/* DIAMETER_Types.ttcn, line 12985 */
const_c__AVP__Code__DCA__3GPP__Subscriber__Role.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Subscriber__Role;
current_location.update_lineno(12987);
/* DIAMETER_Types.ttcn, line 12987 */
const_c__AVP__Code__CxDx__3GPP__SIP__Number__Auth__Items.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__SIP__Number__Auth__Items;
current_location.update_lineno(12989);
/* DIAMETER_Types.ttcn, line 12989 */
const_c__AVP__Code__AAA__3GPP__OMC__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__OMC__Id;
current_location.update_lineno(12991);
/* DIAMETER_Types.ttcn, line 12991 */
const_c__AVP__Code__AAA__3GPP__GMLC__Restriction.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__GMLC__Restriction;
current_location.update_lineno(12993);
/* DIAMETER_Types.ttcn, line 12993 */
const_c__AVP__Code__DNAS__NONE__State.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__State;
current_location.update_lineno(12995);
/* DIAMETER_Types.ttcn, line 12995 */
const_c__AVP__Code__DNAS__NONE__Tunnel__Preference.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunnel__Preference;
current_location.update_lineno(12997);
/* DIAMETER_Types.ttcn, line 12997 */
const_c__AVP__Code__DCC__NONE__CC__Session__Failover.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Session__Failover;
current_location.update_lineno(12999);
/* DIAMETER_Types.ttcn, line 12999 */
const_c__AVP__Code__DCA__3GPP__Enhanced__Diagnostics.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Enhanced__Diagnostics;
current_location.update_lineno(13001);
/* DIAMETER_Types.ttcn, line 13001 */
const_c__AVP__Code__DCA__3GPP__CSG__Membership__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__CSG__Membership__Indication;
current_location.update_lineno(13003);
/* DIAMETER_Types.ttcn, line 13003 */
const_c__AVP__Code__AAA__3GPP__Regional__Subscription__Zone__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Regional__Subscription__Zone__Code;
current_location.update_lineno(13005);
/* DIAMETER_Types.ttcn, line 13005 */
const_c__AVP__Code__DCA__3GPP__Message__Class.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Message__Class;
current_location.update_lineno(13007);
/* DIAMETER_Types.ttcn, line 13007 */
const_c__AVP__Code__GI__3GPP__3GPP__Negotiated__DSCP.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__Negotiated__DSCP;
current_location.update_lineno(13009);
/* DIAMETER_Types.ttcn, line 13009 */
const_c__AVP__Code__AAA__3GPP__TWAN__S2a__Failure__Cause.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__TWAN__S2a__Failure__Cause;
current_location.update_lineno(13011);
/* DIAMETER_Types.ttcn, line 13011 */
const_c__AVP__Code__MIPv4__NONE__MIP__FA__to__MN__SPI.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__FA__to__MN__SPI;
current_location.update_lineno(13013);
/* DIAMETER_Types.ttcn, line 13013 */
const_c__AVP__Code__DCA__3GPP__Trigger.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Trigger;
current_location.update_lineno(13015);
/* DIAMETER_Types.ttcn, line 13015 */
const_c__AVP__Code__DCA__3GPP__Called__Identity__Change.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Called__Identity__Change;
current_location.update_lineno(13017);
/* DIAMETER_Types.ttcn, line 13017 */
const_c__AVP__Code__DCA__3GPP__ProSe__Request__Timestamp.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Request__Timestamp;
current_location.update_lineno(13019);
/* DIAMETER_Types.ttcn, line 13019 */
const_c__AVP__Code__DCA__3GPP__PoC__Session__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__Session__Id;
current_location.update_lineno(13021);
/* DIAMETER_Types.ttcn, line 13021 */
const_c__AVP__Code__BASE__NONE__Proxy__State.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Proxy__State;
current_location.update_lineno(13023);
/* DIAMETER_Types.ttcn, line 13023 */
const_c__AVP__Code__DCA__3GPP__PoC__Server__Role.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__Server__Role;
current_location.update_lineno(13025);
/* DIAMETER_Types.ttcn, line 13025 */
const_c__AVP__Code__DCA__3GPP__Forwarding__Pending.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Forwarding__Pending;
current_location.update_lineno(13027);
/* DIAMETER_Types.ttcn, line 13027 */
const_c__AVP__Code__S6__3GPP__SIR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__SIR__Flags;
current_location.update_lineno(13029);
/* DIAMETER_Types.ttcn, line 13029 */
const_c__AVP__Code__DCC__NONE__Credit__Control__Failure__Handling.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Credit__Control__Failure__Handling;
current_location.update_lineno(13031);
/* DIAMETER_Types.ttcn, line 13031 */
const_c__AVP__Code__MIPv6__NONE__MIP6__Agent__Info.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__MIP6__Agent__Info;
current_location.update_lineno(13033);
/* DIAMETER_Types.ttcn, line 13033 */
const_c__AVP__Code__RX__3GPP__MPS__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__MPS__Identifier;
current_location.update_lineno(13035);
/* DIAMETER_Types.ttcn, line 13035 */
const_c__AVP__Code__PCC__3GPP__Credit__Management__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Credit__Management__Status;
current_location.update_lineno(13037);
/* DIAMETER_Types.ttcn, line 13037 */
const_c__AVP__Code__AAA__3GPP__MDT__Allowed__PLMN__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MDT__Allowed__PLMN__Id;
current_location.update_lineno(13039);
/* DIAMETER_Types.ttcn, line 13039 */
const_c__AVP__Code__DCA__3GPP__Monitored__PLMN__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Monitored__PLMN__Identifier;
current_location.update_lineno(13041);
/* DIAMETER_Types.ttcn, line 13041 */
const_c__AVP__Code__S6__3GPP__Service__Result.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Service__Result;
current_location.update_lineno(13043);
/* DIAMETER_Types.ttcn, line 13043 */
const_c__AVP__Code__PCC__3GPP__Reporting__Level.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Reporting__Level;
current_location.update_lineno(13045);
/* DIAMETER_Types.ttcn, line 13045 */
const_c__AVP__Code__AAA__3GPP__MME__Location__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MME__Location__Information;
current_location.update_lineno(13047);
/* DIAMETER_Types.ttcn, line 13047 */
const_c__AVP__Code__DCA__3GPP__Served__Party__IP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Served__Party__IP__Address;
current_location.update_lineno(13049);
/* DIAMETER_Types.ttcn, line 13049 */
const_c__AVP__Code__RX__3GPP__Max__Supported__Bandwidth__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Max__Supported__Bandwidth__DL;
current_location.update_lineno(13051);
/* DIAMETER_Types.ttcn, line 13051 */
const_c__AVP__Code__DCA__3GPP__Time__First__Reception.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Time__First__Reception;
current_location.update_lineno(13053);
/* DIAMETER_Types.ttcn, line 13053 */
const_c__AVP__Code__PCC__3GPP__Pre__emption__Capability.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Pre__emption__Capability;
current_location.update_lineno(13055);
/* DIAMETER_Types.ttcn, line 13055 */
const_c__AVP__Code__AAA__3GPP__Subscribed__VSRVCC.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Subscribed__VSRVCC;
current_location.update_lineno(13057);
/* DIAMETER_Types.ttcn, line 13057 */
const_c__AVP__Code__PCC__3GPP__Monitoring__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Monitoring__Flags;
current_location.update_lineno(13059);
/* DIAMETER_Types.ttcn, line 13059 */
const_c__AVP__Code__BASE__NONE__Redirect__Max__Cache__Time.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Redirect__Max__Cache__Time;
current_location.update_lineno(13061);
/* DIAMETER_Types.ttcn, line 13061 */
const_c__AVP__Code__CxDx__3GPP__Feature__List.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Feature__List;
current_location.update_lineno(13063);
/* DIAMETER_Types.ttcn, line 13063 */
const_c__AVP__Code__DCA__3GPP__Address__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Address__Type;
current_location.update_lineno(13065);
/* DIAMETER_Types.ttcn, line 13065 */
const_c__AVP__Code__PCC__3GPP__TCP__Source__Port.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__TCP__Source__Port;
current_location.update_lineno(13067);
/* DIAMETER_Types.ttcn, line 13067 */
const_c__AVP__Code__PCC__3GPP__Application__Detection__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Application__Detection__Information;
current_location.update_lineno(13069);
/* DIAMETER_Types.ttcn, line 13069 */
const_c__AVP__Code__AAA__3GPP__Emergency__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Emergency__Info;
current_location.update_lineno(13071);
/* DIAMETER_Types.ttcn, line 13071 */
const_c__AVP__Code__DCA__3GPP__Remaining__Balance.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Remaining__Balance;
current_location.update_lineno(13073);
/* DIAMETER_Types.ttcn, line 13073 */
const_c__AVP__Code__AAA__3GPP__MPS__Priority.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MPS__Priority;
current_location.update_lineno(13075);
/* DIAMETER_Types.ttcn, line 13075 */
const_c__AVP__Code__DCA__3GPP__Next__Tariff.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Next__Tariff;
current_location.update_lineno(13077);
/* DIAMETER_Types.ttcn, line 13077 */
const_c__AVP__Code__DCC__NONE__Requested__Action.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Requested__Action;
current_location.update_lineno(13079);
/* DIAMETER_Types.ttcn, line 13079 */
const_c__AVP__Code__CxDx__3GPP__Record__Route.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Record__Route;
current_location.update_lineno(13081);
/* DIAMETER_Types.ttcn, line 13081 */
const_c__AVP__Code__DCA__3GPP__Tariff__XML.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Tariff__XML;
current_location.update_lineno(13083);
/* DIAMETER_Types.ttcn, line 13083 */
const_c__AVP__Code__AAA__3GPP__Alert__Reason.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Alert__Reason;
current_location.update_lineno(13085);
/* DIAMETER_Types.ttcn, line 13085 */
const_c__AVP__Code__DCA__3GPP__Recipient__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Recipient__Address;
current_location.update_lineno(13087);
/* DIAMETER_Types.ttcn, line 13087 */
const_c__AVP__Code__DCA__3GPP__Change__Condition.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Change__Condition;
current_location.update_lineno(13089);
/* DIAMETER_Types.ttcn, line 13089 */
const_c__AVP__Code__GI__3GPP__3GPP__CG__IPv6__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__CG__IPv6__Address;
current_location.update_lineno(13091);
/* DIAMETER_Types.ttcn, line 13091 */
const_c__AVP__Code__DNAS__NONE__Idle__Timeout.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Idle__Timeout;
current_location.update_lineno(13093);
/* DIAMETER_Types.ttcn, line 13093 */
const_c__AVP__Code__DNAS__NONE__NAS__Port__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__NAS__Port__Id;
current_location.update_lineno(13095);
/* DIAMETER_Types.ttcn, line 13095 */
const_c__AVP__Code__AAA__3GPP__DEA__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__DEA__Flags;
current_location.update_lineno(13097);
/* DIAMETER_Types.ttcn, line 13097 */
const_c__AVP__Code__DCA__3GPP__SCS__AS__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SCS__AS__Address;
current_location.update_lineno(13099);
/* DIAMETER_Types.ttcn, line 13099 */
const_c__AVP__Code__AAA__3GPP__MO__LR.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MO__LR;
current_location.update_lineno(13101);
/* DIAMETER_Types.ttcn, line 13101 */
const_c__AVP__Code__DCA__3GPP__IMS__Visited__Network__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__IMS__Visited__Network__Identifier;
current_location.update_lineno(13103);
/* DIAMETER_Types.ttcn, line 13103 */
const_c__AVP__Code__DCA__3GPP__PoC__User__Role.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__User__Role;
current_location.update_lineno(13105);
/* DIAMETER_Types.ttcn, line 13105 */
const_c__AVP__Code__DCA__3GPP__Announcement__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Announcement__Identifier;
current_location.update_lineno(13107);
/* DIAMETER_Types.ttcn, line 13107 */
const_c__AVP__Code__AAA__3GPP__Non__3GPP__IP__Access.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Non__3GPP__IP__Access;
current_location.update_lineno(13109);
/* DIAMETER_Types.ttcn, line 13109 */
const_c__AVP__Code__DCA__3GPP__Monitoring__Event__Report__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Monitoring__Event__Report__Data;
current_location.update_lineno(13111);
/* DIAMETER_Types.ttcn, line 13111 */
const_c__AVP__Code__DCA__3GPP__Adaptations.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Adaptations;
current_location.update_lineno(13113);
/* DIAMETER_Types.ttcn, line 13113 */
const_c__AVP__Code__BASE__NONE__Host__IP__Address.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Host__IP__Address;
current_location.update_lineno(13115);
/* DIAMETER_Types.ttcn, line 13115 */
const_c__AVP__Code__MIPv4__NONE__MIP__Reg__Request.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Reg__Request;
current_location.update_lineno(13117);
/* DIAMETER_Types.ttcn, line 13117 */
const_c__AVP__Code__DCA__3GPP__Quota__Holding__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Quota__Holding__Time;
current_location.update_lineno(13119);
/* DIAMETER_Types.ttcn, line 13119 */
const_c__AVP__Code__AAA__3GPP__Maximum__Wait__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Maximum__Wait__Time;
current_location.update_lineno(13121);
/* DIAMETER_Types.ttcn, line 13121 */
const_c__AVP__Code__RX__3GPP__Max__Requested__Bandwidth__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Max__Requested__Bandwidth__UL;
current_location.update_lineno(13123);
/* DIAMETER_Types.ttcn, line 13123 */
const_c__AVP__Code__PCC__3GPP__Usage__Monitoring__Support.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Usage__Monitoring__Support;
current_location.update_lineno(13125);
/* DIAMETER_Types.ttcn, line 13125 */
const_c__AVP__Code__S6__3GPP__Maximum__Response__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Maximum__Response__Time;
current_location.update_lineno(13127);
/* DIAMETER_Types.ttcn, line 13127 */
const_c__AVP__Code__DCA__3GPP__Envelope__Reporting.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Envelope__Reporting;
current_location.update_lineno(13129);
/* DIAMETER_Types.ttcn, line 13129 */
const_c__AVP__Code__DCA__3GPP__Application__Server.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Application__Server;
current_location.update_lineno(13131);
/* DIAMETER_Types.ttcn, line 13131 */
const_c__AVP__Code__RX__3GPP__Sponsor__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Sponsor__Identity;
current_location.update_lineno(13133);
/* DIAMETER_Types.ttcn, line 13133 */
const_c__AVP__Code__DNAS__NONE__Framed__Appletalk__Link.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__Appletalk__Link;
current_location.update_lineno(13135);
/* DIAMETER_Types.ttcn, line 13135 */
const_c__AVP__Code__DNAS__NONE__Framed__Interface__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__Interface__Id;
current_location.update_lineno(13137);
/* DIAMETER_Types.ttcn, line 13137 */
const_c__AVP__Code__DCA__3GPP__Proximity__Alert__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Proximity__Alert__Indication;
current_location.update_lineno(13139);
/* DIAMETER_Types.ttcn, line 13139 */
const_c__AVP__Code__PCC__3GPP__CoA__IP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__CoA__IP__Address;
current_location.update_lineno(13141);
/* DIAMETER_Types.ttcn, line 13141 */
const_c__AVP__Code__DCA__3GPP__Trunk__Group__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Trunk__Group__Id;
current_location.update_lineno(13143);
/* DIAMETER_Types.ttcn, line 13143 */
const_c__AVP__Code__PCC__3GPP__Default__QoS__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Default__QoS__Information;
current_location.update_lineno(13145);
/* DIAMETER_Types.ttcn, line 13145 */
const_c__AVP__Code__PCC__3GPP__AN__GW__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__AN__GW__Address;
current_location.update_lineno(13147);
/* DIAMETER_Types.ttcn, line 13147 */
const_c__AVP__Code__DCA__3GPP__Start__Of__Charging.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Start__Of__Charging;
current_location.update_lineno(13149);
/* DIAMETER_Types.ttcn, line 13149 */
const_c__AVP__Code__DCA__3GPP__Participants__Involved.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Participants__Involved;
current_location.update_lineno(13151);
/* DIAMETER_Types.ttcn, line 13151 */
const_c__AVP__Code__PCC__3GPP__NBIFOM__Support.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__NBIFOM__Support;
current_location.update_lineno(13153);
/* DIAMETER_Types.ttcn, line 13153 */
const_c__AVP__Code__PCC__3GPP__Redirect__Support.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Redirect__Support;
current_location.update_lineno(13155);
/* DIAMETER_Types.ttcn, line 13155 */
const_c__AVP__Code__AAA__3GPP__IMSI__Group__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__IMSI__Group__Id;
current_location.update_lineno(13157);
/* DIAMETER_Types.ttcn, line 13157 */
const_c__AVP__Code__AAA__3GPP__Cell__Global__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Cell__Global__Identity;
current_location.update_lineno(13159);
/* DIAMETER_Types.ttcn, line 13159 */
const_c__AVP__Code__BASE__NONE__Vendor__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Vendor__Id;
current_location.update_lineno(13161);
/* DIAMETER_Types.ttcn, line 13161 */
const_c__AVP__Code__AAA__3GPP__PDN__Connection__Continuity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__PDN__Connection__Continuity;
current_location.update_lineno(13163);
/* DIAMETER_Types.ttcn, line 13163 */
const_c__AVP__Code__DCA__3GPP__Tariff__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Tariff__Information;
current_location.update_lineno(13165);
/* DIAMETER_Types.ttcn, line 13165 */
const_c__AVP__Code__CxDx__3GPP__Wildcarded__Public__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Wildcarded__Public__Identity;
current_location.update_lineno(13167);
/* DIAMETER_Types.ttcn, line 13167 */
const_c__AVP__Code__MIPv4__NONE__Acct__Session__Time.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__Acct__Session__Time;
current_location.update_lineno(13169);
/* DIAMETER_Types.ttcn, line 13169 */
const_c__AVP__Code__AAA__3GPP__DSA__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__DSA__Flags;
current_location.update_lineno(13171);
/* DIAMETER_Types.ttcn, line 13171 */
const_c__AVP__Code__DCA__3GPP__PoC__Event__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__Event__Type;
current_location.update_lineno(13173);
/* DIAMETER_Types.ttcn, line 13173 */
const_c__AVP__Code__AAA__3GPP__Trace__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Trace__Data;
current_location.update_lineno(13175);
/* DIAMETER_Types.ttcn, line 13175 */
const_c__AVP__Code__AAA__3GPP__LCS__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__LCS__Info;
current_location.update_lineno(13177);
/* DIAMETER_Types.ttcn, line 13177 */
const_c__AVP__Code__DCA__3GPP__LCS__Requestor__Id__String.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Requestor__Id__String;
current_location.update_lineno(13179);
/* DIAMETER_Types.ttcn, line 13179 */
const_c__AVP__Code__AAA__3GPP__PDN__GW__Allocation__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__PDN__GW__Allocation__Type;
current_location.update_lineno(13181);
/* DIAMETER_Types.ttcn, line 13181 */
const_c__AVP__Code__DCA__3GPP__Additional__Type__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Additional__Type__Information;
current_location.update_lineno(13183);
/* DIAMETER_Types.ttcn, line 13183 */
const_c__AVP__Code__GI__3GPP__3GPP__SGSN__MCC__MNC.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__SGSN__MCC__MNC;
current_location.update_lineno(13185);
/* DIAMETER_Types.ttcn, line 13185 */
const_c__AVP__Code__AAA__3GPP__HESSID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__HESSID;
current_location.update_lineno(13187);
/* DIAMETER_Types.ttcn, line 13187 */
const_c__AVP__Code__DCA__3GPP__Content__Class.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Content__Class;
current_location.update_lineno(13189);
/* DIAMETER_Types.ttcn, line 13189 */
const_c__AVP__Code__BASE__NONE__Event__Timestamp.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Event__Timestamp;
current_location.update_lineno(13191);
/* DIAMETER_Types.ttcn, line 13191 */
const_c__AVP__Code__DCA__3GPP__TAD__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__TAD__Identifier;
current_location.update_lineno(13193);
/* DIAMETER_Types.ttcn, line 13193 */
const_c__AVP__Code__DCC__NONE__Final__Unit__Action.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Final__Unit__Action;
current_location.update_lineno(13195);
/* DIAMETER_Types.ttcn, line 13195 */
const_c__AVP__Code__AAA__3GPP__IMEI__Check__In__VPLMN__Result.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__IMEI__Check__In__VPLMN__Result;
current_location.update_lineno(13197);
/* DIAMETER_Types.ttcn, line 13197 */
const_c__AVP__Code__DCA__3GPP__Service__Generic__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Service__Generic__Information;
current_location.update_lineno(13199);
/* DIAMETER_Types.ttcn, line 13199 */
const_c__AVP__Code__DCA__3GPP__Variable__Part__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Variable__Part__Type;
current_location.update_lineno(13201);
/* DIAMETER_Types.ttcn, line 13201 */
const_c__AVP__Code__DCA__3GPP__ProSe__Direct__Discovery__Model.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Direct__Discovery__Model;
current_location.update_lineno(13203);
/* DIAMETER_Types.ttcn, line 13203 */
const_c__AVP__Code__RX__3GPP__Extended__Max__Requested__BW__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Extended__Max__Requested__BW__UL;
current_location.update_lineno(13205);
/* DIAMETER_Types.ttcn, line 13205 */
const_c__AVP__Code__DCA__3GPP__SM__Device__Trigger__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SM__Device__Trigger__Indicator;
current_location.update_lineno(13207);
/* DIAMETER_Types.ttcn, line 13207 */
const_c__AVP__Code__S6__3GPP__User__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__User__Identifier;
current_location.update_lineno(13209);
/* DIAMETER_Types.ttcn, line 13209 */
const_c__AVP__Code__PCC__3GPP__QoS__Rule__Base__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__QoS__Rule__Base__Name;
current_location.update_lineno(13211);
/* DIAMETER_Types.ttcn, line 13211 */
const_c__AVP__Code__DNAS__NONE__Framed__IPv6__Pool.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__IPv6__Pool;
current_location.update_lineno(13213);
/* DIAMETER_Types.ttcn, line 13213 */
const_c__AVP__Code__AAA__3GPP__Restoration__Priority.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Restoration__Priority;
current_location.update_lineno(13215);
/* DIAMETER_Types.ttcn, line 13215 */
const_c__AVP__Code__DCA__3GPP__ISUP__Cause__Diagnostics.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ISUP__Cause__Diagnostics;
current_location.update_lineno(13217);
/* DIAMETER_Types.ttcn, line 13217 */
const_c__AVP__Code__S6__3GPP__Association__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Association__Type;
current_location.update_lineno(13219);
/* DIAMETER_Types.ttcn, line 13219 */
const_c__AVP__Code__PCC__3GPP__Charging__Rule__Definition.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Charging__Rule__Definition;
current_location.update_lineno(13221);
/* DIAMETER_Types.ttcn, line 13221 */
const_c__AVP__Code__DCC__NONE__Rating__Group.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Rating__Group;
current_location.update_lineno(13223);
/* DIAMETER_Types.ttcn, line 13223 */
const_c__AVP__Code__MIPv6__NONE__MIP__MN__HA__SPI.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__MIP__MN__HA__SPI;
current_location.update_lineno(13225);
/* DIAMETER_Types.ttcn, line 13225 */
const_c__AVP__Code__RX__3GPP__Min__Requested__Bandwidth__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Min__Requested__Bandwidth__UL;
current_location.update_lineno(13227);
/* DIAMETER_Types.ttcn, line 13227 */
const_c__AVP__Code__DCA__3GPP__Application__Specific__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Application__Specific__Data;
current_location.update_lineno(13229);
/* DIAMETER_Types.ttcn, line 13229 */
const_c__AVP__Code__PCC__3GPP__CoA__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__CoA__Information;
current_location.update_lineno(13231);
/* DIAMETER_Types.ttcn, line 13231 */
const_c__AVP__Code__AAA__3GPP__Report__Amount.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Report__Amount;
current_location.update_lineno(13233);
/* DIAMETER_Types.ttcn, line 13233 */
const_c__AVP__Code__CxDx__3GPP__Secondary__Charging__Collection__Function__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Secondary__Charging__Collection__Function__Name;
current_location.update_lineno(13235);
/* DIAMETER_Types.ttcn, line 13235 */
const_c__AVP__Code__DCC__NONE__User__Equipment__Info.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__User__Equipment__Info;
current_location.update_lineno(13237);
/* DIAMETER_Types.ttcn, line 13237 */
const_c__AVP__Code__AAA__3GPP__A__MSISDN.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__A__MSISDN;
current_location.update_lineno(13239);
/* DIAMETER_Types.ttcn, line 13239 */
const_c__AVP__Code__MIPv4__NONE__MIP__Mobile__Node__Address.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Mobile__Node__Address;
current_location.update_lineno(13241);
/* DIAMETER_Types.ttcn, line 13241 */
const_c__AVP__Code__PCC__3GPP__Routing__Rule__Report.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Routing__Rule__Report;
current_location.update_lineno(13243);
/* DIAMETER_Types.ttcn, line 13243 */
const_c__AVP__Code__AAA__3GPP__Number__Of__Requested__Vectors.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Number__Of__Requested__Vectors;
current_location.update_lineno(13245);
/* DIAMETER_Types.ttcn, line 13245 */
const_c__AVP__Code__AAA__3GPP__AIR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__AIR__Flags;
current_location.update_lineno(13247);
/* DIAMETER_Types.ttcn, line 13247 */
const_c__AVP__Code__DCA__3GPP__SM__Protocol__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SM__Protocol__ID;
current_location.update_lineno(13249);
/* DIAMETER_Types.ttcn, line 13249 */
const_c__AVP__Code__DCA__3GPP__Low__Priority__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Low__Priority__Indicator;
current_location.update_lineno(13251);
/* DIAMETER_Types.ttcn, line 13251 */
const_c__AVP__Code__AAA__3GPP__Geographical__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Geographical__Information;
current_location.update_lineno(13253);
/* DIAMETER_Types.ttcn, line 13253 */
const_c__AVP__Code__DCA__3GPP__Participant__Action__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Participant__Action__Type;
current_location.update_lineno(13255);
/* DIAMETER_Types.ttcn, line 13255 */
const_c__AVP__Code__DCA__3GPP__Node__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Node__Id;
current_location.update_lineno(13257);
/* DIAMETER_Types.ttcn, line 13257 */
const_c__AVP__Code__CxDx__3GPP__Loose__Route__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Loose__Route__Indication;
current_location.update_lineno(13259);
/* DIAMETER_Types.ttcn, line 13259 */
const_c__AVP__Code__DCC__NONE__Service__Parameter__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Service__Parameter__Type;
current_location.update_lineno(13261);
/* DIAMETER_Types.ttcn, line 13261 */
const_c__AVP__Code__AAA__3GPP__MME__User__State.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MME__User__State;
current_location.update_lineno(13263);
/* DIAMETER_Types.ttcn, line 13263 */
const_c__AVP__Code__AAA__3GPP__Access__Restriction__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Access__Restriction__Data;
current_location.update_lineno(13265);
/* DIAMETER_Types.ttcn, line 13265 */
const_c__AVP__Code__DCA__3GPP__SM__Service__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SM__Service__Type;
current_location.update_lineno(13267);
/* DIAMETER_Types.ttcn, line 13267 */
const_c__AVP__Code__DCA__3GPP__UNI__PDU__CP__Only__Flag.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__UNI__PDU__CP__Only__Flag;
current_location.update_lineno(13269);
/* DIAMETER_Types.ttcn, line 13269 */
const_c__AVP__Code__MIPv4__NONE__MIP__Filter__Rule.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Filter__Rule;
current_location.update_lineno(13271);
/* DIAMETER_Types.ttcn, line 13271 */
const_c__AVP__Code__BASE__NONE__Failed__AVP.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Failed__AVP;
current_location.update_lineno(13273);
/* DIAMETER_Types.ttcn, line 13273 */
const_c__AVP__Code__GI__3GPP__3GPP__RAT__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__RAT__Type;
current_location.update_lineno(13275);
/* DIAMETER_Types.ttcn, line 13275 */
const_c__AVP__Code__AAA__3GPP__SS__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SS__Status;
current_location.update_lineno(13277);
/* DIAMETER_Types.ttcn, line 13277 */
const_c__AVP__Code__DCA__3GPP__Neighbour__Node__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Neighbour__Node__Address;
current_location.update_lineno(13279);
/* DIAMETER_Types.ttcn, line 13279 */
const_c__AVP__Code__DCA__3GPP__Location__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Location__Type;
current_location.update_lineno(13281);
/* DIAMETER_Types.ttcn, line 13281 */
const_c__AVP__Code__DCA__3GPP__Quota__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Quota__Indicator;
current_location.update_lineno(13283);
/* DIAMETER_Types.ttcn, line 13283 */
const_c__AVP__Code__DCA__3GPP__Priority.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Priority;
current_location.update_lineno(13285);
/* DIAMETER_Types.ttcn, line 13285 */
const_c__AVP__Code__S6__3GPP__NIDD__Authorization__Update.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__NIDD__Authorization__Update;
current_location.update_lineno(13287);
/* DIAMETER_Types.ttcn, line 13287 */
const_c__AVP__Code__DCA__3GPP__Service__Specific__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Service__Specific__Data;
current_location.update_lineno(13289);
/* DIAMETER_Types.ttcn, line 13289 */
const_c__AVP__Code__DCC__NONE__Subscription__Id__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Subscription__Id__Type;
current_location.update_lineno(13291);
/* DIAMETER_Types.ttcn, line 13291 */
const_c__AVP__Code__MIPv4__NONE__MIP__FA__to__HA__MSA.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__FA__to__HA__MSA;
current_location.update_lineno(13293);
/* DIAMETER_Types.ttcn, line 13293 */
const_c__AVP__Code__AAA__3GPP__Connectivity__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Connectivity__Flags;
current_location.update_lineno(13295);
/* DIAMETER_Types.ttcn, line 13295 */
const_c__AVP__Code__PCC__3GPP__Packet__Filter__Operation.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Packet__Filter__Operation;
current_location.update_lineno(13297);
/* DIAMETER_Types.ttcn, line 13297 */
const_c__AVP__Code__DCA__3GPP__VCS__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__VCS__Information;
current_location.update_lineno(13299);
/* DIAMETER_Types.ttcn, line 13299 */
const_c__AVP__Code__S6__3GPP__SCEF__Reference__ID__for__Deletion.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__SCEF__Reference__ID__for__Deletion;
current_location.update_lineno(13301);
/* DIAMETER_Types.ttcn, line 13301 */
const_c__AVP__Code__DCA__3GPP__Content__Disposition.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Content__Disposition;
current_location.update_lineno(13303);
/* DIAMETER_Types.ttcn, line 13303 */
const_c__AVP__Code__RX__3GPP__SIP__Forking__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__SIP__Forking__Indication;
current_location.update_lineno(13305);
/* DIAMETER_Types.ttcn, line 13305 */
const_c__AVP__Code__DNAS__NONE__User__Password.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__User__Password;
current_location.update_lineno(13307);
/* DIAMETER_Types.ttcn, line 13307 */
const_c__AVP__Code__DCA__3GPP__ProSe__Group__IP__Multicast__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Group__IP__Multicast__Address;
current_location.update_lineno(13309);
/* DIAMETER_Types.ttcn, line 13309 */
const_c__AVP__Code__S6__3GPP__IMEI__Change.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__IMEI__Change;
current_location.update_lineno(13311);
/* DIAMETER_Types.ttcn, line 13311 */
const_c__AVP__Code__PCC__3GPP__IP__CAN__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__IP__CAN__Type;
current_location.update_lineno(13313);
/* DIAMETER_Types.ttcn, line 13313 */
const_c__AVP__Code__DCA__3GPP__SDP__Media__Component.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SDP__Media__Component;
current_location.update_lineno(13315);
/* DIAMETER_Types.ttcn, line 13315 */
const_c__AVP__Code__RX__3GPP__Extended__Min__Desired__BW__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Extended__Min__Desired__BW__UL;
current_location.update_lineno(13317);
/* DIAMETER_Types.ttcn, line 13317 */
const_c__AVP__Code__DCA__3GPP__ProSe__Direct__Communication__Reception__Data__Container.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Direct__Communication__Reception__Data__Container;
current_location.update_lineno(13319);
/* DIAMETER_Types.ttcn, line 13319 */
const_c__AVP__Code__CxDx__3GPP__SIP__Authorization.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__SIP__Authorization;
current_location.update_lineno(13321);
/* DIAMETER_Types.ttcn, line 13321 */
const_c__AVP__Code__PCC__3GPP__Revalidation__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Revalidation__Time;
current_location.update_lineno(13323);
/* DIAMETER_Types.ttcn, line 13323 */
const_c__AVP__Code__AAA__3GPP__Logging__Interval.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Logging__Interval;
current_location.update_lineno(13325);
/* DIAMETER_Types.ttcn, line 13325 */
const_c__AVP__Code__DCA__3GPP__PoC__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__Information;
current_location.update_lineno(13327);
/* DIAMETER_Types.ttcn, line 13327 */
const_c__AVP__Code__PCC__3GPP__Presence__Reporting__Area__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Presence__Reporting__Area__Status;
current_location.update_lineno(13329);
/* DIAMETER_Types.ttcn, line 13329 */
const_c__AVP__Code__PCC__3GPP__Routing__Filter.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Routing__Filter;
current_location.update_lineno(13331);
/* DIAMETER_Types.ttcn, line 13331 */
const_c__AVP__Code__AAA__3GPP__WLAN__offloadability.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__WLAN__offloadability;
current_location.update_lineno(13333);
/* DIAMETER_Types.ttcn, line 13333 */
const_c__AVP__Code__DCA__3GPP__Data__Coding__Scheme.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Data__Coding__Scheme;
current_location.update_lineno(13335);
/* DIAMETER_Types.ttcn, line 13335 */
const_c__AVP__Code__PCC__3GPP__Metering__Method.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Metering__Method;
current_location.update_lineno(13337);
/* DIAMETER_Types.ttcn, line 13337 */
const_c__AVP__Code__DNAS__NONE__Acct__Tunnel__Connection.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Acct__Tunnel__Connection;
current_location.update_lineno(13339);
/* DIAMETER_Types.ttcn, line 13339 */
const_c__AVP__Code__AAA__3GPP__Non__IP__Data__Delivery__Mechanism.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Non__IP__Data__Delivery__Mechanism;
current_location.update_lineno(13341);
/* DIAMETER_Types.ttcn, line 13341 */
const_c__AVP__Code__DCA__3GPP__Initial__IMS__Charging__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Initial__IMS__Charging__Identifier;
current_location.update_lineno(13343);
/* DIAMETER_Types.ttcn, line 13343 */
const_c__AVP__Code__DNAS__NONE__NAS__Filter__Rule.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__NAS__Filter__Rule;
current_location.update_lineno(13345);
/* DIAMETER_Types.ttcn, line 13345 */
const_c__AVP__Code__MIPv4__NONE__MIP__Feature__Vector.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Feature__Vector;
current_location.update_lineno(13347);
/* DIAMETER_Types.ttcn, line 13347 */
const_c__AVP__Code__BASE__NONE__Session__Server__Failover.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Session__Server__Failover;
current_location.update_lineno(13349);
/* DIAMETER_Types.ttcn, line 13349 */
const_c__AVP__Code__DCA__3GPP__Accumulated__Cost.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Accumulated__Cost;
current_location.update_lineno(13351);
/* DIAMETER_Types.ttcn, line 13351 */
const_c__AVP__Code__CxDx__3GPP__Integrity__Key.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Integrity__Key;
current_location.update_lineno(13353);
/* DIAMETER_Types.ttcn, line 13353 */
const_c__AVP__Code__AAA__3GPP__E__UTRAN__Vector.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__E__UTRAN__Vector;
current_location.update_lineno(13355);
/* DIAMETER_Types.ttcn, line 13355 */
const_c__AVP__Code__DCA__3GPP__SMSC__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SMSC__Address;
current_location.update_lineno(13357);
/* DIAMETER_Types.ttcn, line 13357 */
const_c__AVP__Code__DCA__3GPP__PDP__Address__Prefix__Length.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PDP__Address__Prefix__Length;
current_location.update_lineno(13359);
/* DIAMETER_Types.ttcn, line 13359 */
const_c__AVP__Code__BASE__NONE__Experimental__Result.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Experimental__Result;
current_location.update_lineno(13361);
/* DIAMETER_Types.ttcn, line 13361 */
const_c__AVP__Code__DNAS__NONE__Acct__Link__Count.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Acct__Link__Count;
current_location.update_lineno(13363);
/* DIAMETER_Types.ttcn, line 13363 */
const_c__AVP__Code__DCC__NONE__Unit__Value.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Unit__Value;
current_location.update_lineno(13365);
/* DIAMETER_Types.ttcn, line 13365 */
const_c__AVP__Code__AAA__3GPP__Trace__Event__List.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Trace__Event__List;
current_location.update_lineno(13367);
/* DIAMETER_Types.ttcn, line 13367 */
const_c__AVP__Code__DCA__3GPP__LCS__Client__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Client__Id;
current_location.update_lineno(13369);
/* DIAMETER_Types.ttcn, line 13369 */
const_c__AVP__Code__GI__3GPP__3GPP__PDP__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__PDP__Type;
current_location.update_lineno(13371);
/* DIAMETER_Types.ttcn, line 13371 */
const_c__AVP__Code__DNAS__NONE__Reply__Message.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Reply__Message;
current_location.update_lineno(13373);
/* DIAMETER_Types.ttcn, line 13373 */
const_c__AVP__Code__DNAS__NONE__Connect__Info.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Connect__Info;
current_location.update_lineno(13375);
/* DIAMETER_Types.ttcn, line 13375 */
const_c__AVP__Code__MIPv4__NONE__MIP__Replay__Mode.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Replay__Mode;
current_location.update_lineno(13377);
/* DIAMETER_Types.ttcn, line 13377 */
const_c__AVP__Code__BASE__NONE__Proxy__Host.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Proxy__Host;
current_location.update_lineno(13379);
/* DIAMETER_Types.ttcn, line 13379 */
const_c__AVP__Code__DCA__3GPP__Number__Of__Talk__Bursts.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Number__Of__Talk__Bursts;
current_location.update_lineno(13381);
/* DIAMETER_Types.ttcn, line 13381 */
const_c__AVP__Code__AAA__3GPP__Short__Network__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Short__Network__Name;
current_location.update_lineno(13383);
/* DIAMETER_Types.ttcn, line 13383 */
const_c__AVP__Code__DCA__3GPP__Message__Size.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Message__Size;
current_location.update_lineno(13385);
/* DIAMETER_Types.ttcn, line 13385 */
const_c__AVP__Code__DCA__3GPP__Additional__Exception__Reports.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Additional__Exception__Reports;
current_location.update_lineno(13387);
/* DIAMETER_Types.ttcn, line 13387 */
const_c__AVP__Code__DCA__3GPP__Access__Transfer__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Access__Transfer__Information;
current_location.update_lineno(13389);
/* DIAMETER_Types.ttcn, line 13389 */
const_c__AVP__Code__S6__3GPP__Communication__Pattern__Set.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Communication__Pattern__Set;
current_location.update_lineno(13391);
/* DIAMETER_Types.ttcn, line 13391 */
const_c__AVP__Code__AAA__3GPP__TWAG__UP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__TWAG__UP__Address;
current_location.update_lineno(13393);
/* DIAMETER_Types.ttcn, line 13393 */
const_c__AVP__Code__DCA__3GPP__MMBox__Storage__Requested.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MMBox__Storage__Requested;
current_location.update_lineno(13395);
/* DIAMETER_Types.ttcn, line 13395 */
const_c__AVP__Code__RX__3GPP__Flow__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Flow__Status;
current_location.update_lineno(13397);
/* DIAMETER_Types.ttcn, line 13397 */
const_c__AVP__Code__DNAS__NONE__CHAP__Challenge.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__CHAP__Challenge;
current_location.update_lineno(13399);
/* DIAMETER_Types.ttcn, line 13399 */
const_c__AVP__Code__DCA__3GPP__PC3__Control__Protocol__Cause.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PC3__Control__Protocol__Cause;
current_location.update_lineno(13401);
/* DIAMETER_Types.ttcn, line 13401 */
const_c__AVP__Code__DCC__NONE__CC__Unit__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Unit__Type;
current_location.update_lineno(13403);
/* DIAMETER_Types.ttcn, line 13403 */
const_c__AVP__Code__DCA__3GPP__Calling__Party__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Calling__Party__Address;
current_location.update_lineno(13405);
/* DIAMETER_Types.ttcn, line 13405 */
const_c__AVP__Code__RX__3GPP__MCPTT__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__MCPTT__Identifier;
current_location.update_lineno(13407);
/* DIAMETER_Types.ttcn, line 13407 */
const_c__AVP__Code__S6__3GPP__Group__Monitoring__Event__Report.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Group__Monitoring__Event__Report;
current_location.update_lineno(13409);
/* DIAMETER_Types.ttcn, line 13409 */
const_c__AVP__Code__PCC__3GPP__QoS__Upgrade.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__QoS__Upgrade;
current_location.update_lineno(13411);
/* DIAMETER_Types.ttcn, line 13411 */
const_c__AVP__Code__DCA__3GPP__PS__Append__Free__Format__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PS__Append__Free__Format__Data;
current_location.update_lineno(13413);
/* DIAMETER_Types.ttcn, line 13413 */
const_c__AVP__Code__PCC__3GPP__AN__GW__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__AN__GW__Status;
current_location.update_lineno(13415);
/* DIAMETER_Types.ttcn, line 13415 */
const_c__AVP__Code__DNAS__NONE__Service__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Service__Type;
current_location.update_lineno(13417);
/* DIAMETER_Types.ttcn, line 13417 */
const_c__AVP__Code__PCC__3GPP__Monitoring__Key.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Monitoring__Key;
current_location.update_lineno(13419);
/* DIAMETER_Types.ttcn, line 13419 */
const_c__AVP__Code__AAA__3GPP__Measurement__Period__UMTS.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Measurement__Period__UMTS;
current_location.update_lineno(13421);
/* DIAMETER_Types.ttcn, line 13421 */
const_c__AVP__Code__DCA__3GPP__Media__Initiator__Flag.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Media__Initiator__Flag;
current_location.update_lineno(13423);
/* DIAMETER_Types.ttcn, line 13423 */
const_c__AVP__Code__DCA__3GPP__ISUP__Location__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ISUP__Location__Number;
current_location.update_lineno(13425);
/* DIAMETER_Types.ttcn, line 13425 */
const_c__AVP__Code__PCC__3GPP__3GPP__PS__Data__Off__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__3GPP__PS__Data__Off__Status;
current_location.update_lineno(13427);
/* DIAMETER_Types.ttcn, line 13427 */
const_c__AVP__Code__PCC__3GPP__Routing__Rule__Install.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Routing__Rule__Install;
current_location.update_lineno(13429);
/* DIAMETER_Types.ttcn, line 13429 */
const_c__AVP__Code__AAA__3GPP__Reset__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Reset__ID;
current_location.update_lineno(13431);
/* DIAMETER_Types.ttcn, line 13431 */
const_c__AVP__Code__DCA__3GPP__Service__Data__Container.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Service__Data__Container;
current_location.update_lineno(13433);
/* DIAMETER_Types.ttcn, line 13433 */
const_c__AVP__Code__CxDx__3GPP__Server__Assignment__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Server__Assignment__Type;
current_location.update_lineno(13435);
/* DIAMETER_Types.ttcn, line 13435 */
const_c__AVP__Code__AAA__3GPP__PUR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__PUR__Flags;
current_location.update_lineno(13437);
/* DIAMETER_Types.ttcn, line 13437 */
const_c__AVP__Code__PCC__3GPP__IP__CAN__Session__Charging__Scope.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__IP__CAN__Session__Charging__Scope;
current_location.update_lineno(13439);
/* DIAMETER_Types.ttcn, line 13439 */
const_c__AVP__Code__DNAS__NONE__Framed__Routing.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__Routing;
current_location.update_lineno(13441);
/* DIAMETER_Types.ttcn, line 13441 */
const_c__AVP__Code__AAA__3GPP__IMEI.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__IMEI;
current_location.update_lineno(13443);
/* DIAMETER_Types.ttcn, line 13443 */
const_c__AVP__Code__DNAS__NONE__CHAP__Ident.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__CHAP__Ident;
current_location.update_lineno(13445);
/* DIAMETER_Types.ttcn, line 13445 */
const_c__AVP__Code__DCA__3GPP__Interface__Text.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Interface__Text;
current_location.update_lineno(13447);
/* DIAMETER_Types.ttcn, line 13447 */
const_c__AVP__Code__AAA__3GPP__Kc.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Kc;
current_location.update_lineno(13449);
/* DIAMETER_Types.ttcn, line 13449 */
const_c__AVP__Code__DCA__3GPP__Current__Tariff.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Current__Tariff;
current_location.update_lineno(13451);
/* DIAMETER_Types.ttcn, line 13451 */
const_c__AVP__Code__AAA__3GPP__SGSN__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SGSN__Number;
current_location.update_lineno(13453);
/* DIAMETER_Types.ttcn, line 13453 */
const_c__AVP__Code__AAA__3GPP__HPLMN__ODB.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__HPLMN__ODB;
current_location.update_lineno(13455);
/* DIAMETER_Types.ttcn, line 13455 */
const_c__AVP__Code__DCA__3GPP__Time__Quota__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Time__Quota__Type;
current_location.update_lineno(13457);
/* DIAMETER_Types.ttcn, line 13457 */
const_c__AVP__Code__AAA__3GPP__Trace__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Trace__Info;
current_location.update_lineno(13459);
/* DIAMETER_Types.ttcn, line 13459 */
const_c__AVP__Code__DCA__3GPP__Domain__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Domain__Name;
current_location.update_lineno(13461);
/* DIAMETER_Types.ttcn, line 13461 */
const_c__AVP__Code__GI__3GPP__3GPP__Charging__Characteristics.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__Charging__Characteristics;
current_location.update_lineno(13463);
/* DIAMETER_Types.ttcn, line 13463 */
const_c__AVP__Code__AAA__3GPP__PDP__Context.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__PDP__Context;
current_location.update_lineno(13465);
/* DIAMETER_Types.ttcn, line 13465 */
const_c__AVP__Code__DCC__NONE__CC__Money.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Money;
current_location.update_lineno(13467);
/* DIAMETER_Types.ttcn, line 13467 */
const_c__AVP__Code__AAA__3GPP__DER__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__DER__Flags;
current_location.update_lineno(13469);
/* DIAMETER_Types.ttcn, line 13469 */
const_c__AVP__Code__DCA__3GPP__LCS__Data__Coding__Scheme.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Data__Coding__Scheme;
current_location.update_lineno(13471);
/* DIAMETER_Types.ttcn, line 13471 */
const_c__AVP__Code__GI__3GPP__3GPP__GGSN__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__GGSN__Address;
current_location.update_lineno(13473);
/* DIAMETER_Types.ttcn, line 13473 */
const_c__AVP__Code__BASE__NONE__Proxy__Info.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Proxy__Info;
current_location.update_lineno(13475);
/* DIAMETER_Types.ttcn, line 13475 */
const_c__AVP__Code__DCA__3GPP__Related__IMS__Charging__Identifier__Node.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Related__IMS__Charging__Identifier__Node;
current_location.update_lineno(13477);
/* DIAMETER_Types.ttcn, line 13477 */
const_c__AVP__Code__S6__3GPP__Node__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Node__Type;
current_location.update_lineno(13479);
/* DIAMETER_Types.ttcn, line 13479 */
const_c__AVP__Code__DCA__3GPP__Talk__Burst__Volume.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Talk__Burst__Volume;
current_location.update_lineno(13481);
/* DIAMETER_Types.ttcn, line 13481 */
const_c__AVP__Code__DCA__3GPP__Service__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Service__Id;
current_location.update_lineno(13483);
/* DIAMETER_Types.ttcn, line 13483 */
const_c__AVP__Code__RX__3GPP__Priority__Sharing__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Priority__Sharing__Indicator;
current_location.update_lineno(13485);
/* DIAMETER_Types.ttcn, line 13485 */
const_c__AVP__Code__DNAS__NONE__Tunnel__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunnel__Type;
current_location.update_lineno(13487);
/* DIAMETER_Types.ttcn, line 13487 */
const_c__AVP__Code__PCC__3GPP__QoS__Rule__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__QoS__Rule__Name;
current_location.update_lineno(13489);
/* DIAMETER_Types.ttcn, line 13489 */
const_c__AVP__Code__DCA__3GPP__Trigger__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Trigger__Type;
current_location.update_lineno(13491);
/* DIAMETER_Types.ttcn, line 13491 */
const_c__AVP__Code__DCA__3GPP__Instance__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Instance__Id;
current_location.update_lineno(13493);
/* DIAMETER_Types.ttcn, line 13493 */
const_c__AVP__Code__S6__3GPP__Scheduled__Communication__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Scheduled__Communication__Time;
current_location.update_lineno(13495);
/* DIAMETER_Types.ttcn, line 13495 */
const_c__AVP__Code__RX__3GPP__Max__Requested__Bandwidth__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Max__Requested__Bandwidth__DL;
current_location.update_lineno(13497);
/* DIAMETER_Types.ttcn, line 13497 */
const_c__AVP__Code__DCA__3GPP__Role__Of__ProSe__Function.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Role__Of__ProSe__Function;
current_location.update_lineno(13499);
/* DIAMETER_Types.ttcn, line 13499 */
const_c__AVP__Code__S6__3GPP__Maximum__Latency.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Maximum__Latency;
current_location.update_lineno(13501);
/* DIAMETER_Types.ttcn, line 13501 */
const_c__AVP__Code__PCC__3GPP__PCC__Rule__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__PCC__Rule__Status;
current_location.update_lineno(13503);
/* DIAMETER_Types.ttcn, line 13503 */
const_c__AVP__Code__DCA__3GPP__SIP__Response__Timestamp.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SIP__Response__Timestamp;
current_location.update_lineno(13505);
/* DIAMETER_Types.ttcn, line 13505 */
const_c__AVP__Code__PCC__3GPP__Extended__GBR__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Extended__GBR__DL;
current_location.update_lineno(13507);
/* DIAMETER_Types.ttcn, line 13507 */
const_c__AVP__Code__AAA__3GPP__MBSFN__Area.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MBSFN__Area;
current_location.update_lineno(13509);
/* DIAMETER_Types.ttcn, line 13509 */
const_c__AVP__Code__DCA__3GPP__ProSe__UE__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__UE__ID;
current_location.update_lineno(13511);
/* DIAMETER_Types.ttcn, line 13511 */
const_c__AVP__Code__CxDx__3GPP__Server__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Server__Name;
current_location.update_lineno(13513);
/* DIAMETER_Types.ttcn, line 13513 */
const_c__AVP__Code__S6__3GPP__APN__Validity__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__APN__Validity__Time;
current_location.update_lineno(13515);
/* DIAMETER_Types.ttcn, line 13515 */
const_c__AVP__Code__PCC__3GPP__Allocation__Retention__Priority.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Allocation__Retention__Priority;
current_location.update_lineno(13517);
/* DIAMETER_Types.ttcn, line 13517 */
const_c__AVP__Code__DCC__NONE__Check__Balance__Result.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Check__Balance__Result;
current_location.update_lineno(13519);
/* DIAMETER_Types.ttcn, line 13519 */
const_c__AVP__Code__AAA__3GPP__Job__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Job__Type;
current_location.update_lineno(13521);
/* DIAMETER_Types.ttcn, line 13521 */
const_c__AVP__Code__BASE__NONE__Destination__Host.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Destination__Host;
current_location.update_lineno(13523);
/* DIAMETER_Types.ttcn, line 13523 */
const_c__AVP__Code__AAA__3GPP__Positioning__Method.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Positioning__Method;
current_location.update_lineno(13525);
/* DIAMETER_Types.ttcn, line 13525 */
const_c__AVP__Code__CxDx__3GPP__LIA__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__LIA__Flags;
current_location.update_lineno(13527);
/* DIAMETER_Types.ttcn, line 13527 */
const_c__AVP__Code__AAA__3GPP__DL__Buffering__Suggested__Packet__Count.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__DL__Buffering__Suggested__Packet__Count;
current_location.update_lineno(13529);
/* DIAMETER_Types.ttcn, line 13529 */
const_c__AVP__Code__DCA__3GPP__AoC__Service__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__AoC__Service__Type;
current_location.update_lineno(13531);
/* DIAMETER_Types.ttcn, line 13531 */
const_c__AVP__Code__DNAS__NONE__Login__IP__Host.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Login__IP__Host;
current_location.update_lineno(13533);
/* DIAMETER_Types.ttcn, line 13533 */
const_c__AVP__Code__AAA__3GPP__IDA__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__IDA__Flags;
current_location.update_lineno(13535);
/* DIAMETER_Types.ttcn, line 13535 */
const_c__AVP__Code__DNAS__NONE__ARAP__Security.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__ARAP__Security;
current_location.update_lineno(13537);
/* DIAMETER_Types.ttcn, line 13537 */
const_c__AVP__Code__DNAS__NONE__Origin__AAA__Protocol.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Origin__AAA__Protocol;
current_location.update_lineno(13539);
/* DIAMETER_Types.ttcn, line 13539 */
const_c__AVP__Code__DCA__3GPP__Time__Last__Usage.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Time__Last__Usage;
current_location.update_lineno(13541);
/* DIAMETER_Types.ttcn, line 13541 */
const_c__AVP__Code__CxDx__3GPP__Charging__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Charging__Information;
current_location.update_lineno(13543);
/* DIAMETER_Types.ttcn, line 13543 */
const_c__AVP__Code__AAA__3GPP__ULA__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__ULA__Flags;
current_location.update_lineno(13545);
/* DIAMETER_Types.ttcn, line 13545 */
const_c__AVP__Code__DCA__3GPP__Originator__Interface.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Originator__Interface;
current_location.update_lineno(13547);
/* DIAMETER_Types.ttcn, line 13547 */
const_c__AVP__Code__AAA__3GPP__IMS__Voice__Over__PS__Sessions__Supported.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__IMS__Voice__Over__PS__Sessions__Supported;
current_location.update_lineno(13549);
/* DIAMETER_Types.ttcn, line 13549 */
const_c__AVP__Code__AAA__3GPP__Roaming__Restricted__Due__To__Unsupported__Feature.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Roaming__Restricted__Due__To__Unsupported__Feature;
current_location.update_lineno(13551);
/* DIAMETER_Types.ttcn, line 13551 */
const_c__AVP__Code__DCA__3GPP__File__Repair__Supported.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__File__Repair__Supported;
current_location.update_lineno(13553);
/* DIAMETER_Types.ttcn, line 13553 */
const_c__AVP__Code__DNAS__NONE__Framed__IPX__Network.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__IPX__Network;
current_location.update_lineno(13555);
/* DIAMETER_Types.ttcn, line 13555 */
const_c__AVP__Code__DNAS__NONE__Tunnel__Assignment__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunnel__Assignment__Id;
current_location.update_lineno(13557);
/* DIAMETER_Types.ttcn, line 13557 */
const_c__AVP__Code__DCC__NONE__CC__Service__Specific__Units.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Service__Specific__Units;
current_location.update_lineno(13559);
/* DIAMETER_Types.ttcn, line 13559 */
const_c__AVP__Code__DCA__3GPP__SDP__Answer__Timestamp.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SDP__Answer__Timestamp;
current_location.update_lineno(13561);
/* DIAMETER_Types.ttcn, line 13561 */
const_c__AVP__Code__AAA__3GPP__WLAN__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__WLAN__Identifier;
current_location.update_lineno(13563);
/* DIAMETER_Types.ttcn, line 13563 */
const_c__AVP__Code__DCA__3GPP__Type__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Type__Number;
current_location.update_lineno(13565);
/* DIAMETER_Types.ttcn, line 13565 */
const_c__AVP__Code__DCA__3GPP__NIDD__Submission.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__NIDD__Submission;
current_location.update_lineno(13567);
/* DIAMETER_Types.ttcn, line 13567 */
const_c__AVP__Code__S6__3GPP__T4__Parameters.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__T4__Parameters;
current_location.update_lineno(13569);
/* DIAMETER_Types.ttcn, line 13569 */
const_c__AVP__Code__RX__3GPP__Access__Network__Charging__Identifier__Value.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Access__Network__Charging__Identifier__Value;
current_location.update_lineno(13571);
/* DIAMETER_Types.ttcn, line 13571 */
const_c__AVP__Code__DCA__3GPP__Announcing__UE__HPLMN__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Announcing__UE__HPLMN__Identifier;
current_location.update_lineno(13573);
/* DIAMETER_Types.ttcn, line 13573 */
const_c__AVP__Code__S6__3GPP__AESE__Error__Report.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__AESE__Error__Report;
current_location.update_lineno(13575);
/* DIAMETER_Types.ttcn, line 13575 */
const_c__AVP__Code__MIPv4__NONE__MIP__FA__to__HA__SPI.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__FA__to__HA__SPI;
current_location.update_lineno(13577);
/* DIAMETER_Types.ttcn, line 13577 */
const_c__AVP__Code__DCA__3GPP__Event__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Event__Type;
current_location.update_lineno(13579);
/* DIAMETER_Types.ttcn, line 13579 */
const_c__AVP__Code__RX__3GPP__Sharing__Key__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Sharing__Key__DL;
current_location.update_lineno(13581);
/* DIAMETER_Types.ttcn, line 13581 */
const_c__AVP__Code__PCC__3GPP__ADC__Rule__Remove.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__ADC__Rule__Remove;
current_location.update_lineno(13583);
/* DIAMETER_Types.ttcn, line 13583 */
const_c__AVP__Code__DCA__3GPP__ProSe__Direct__Communication__Transmission__Data__Container.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Direct__Communication__Transmission__Data__Container;
current_location.update_lineno(13585);
/* DIAMETER_Types.ttcn, line 13585 */
const_c__AVP__Code__S6__3GPP__Restricted__PLMN__List.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Restricted__PLMN__List;
current_location.update_lineno(13587);
/* DIAMETER_Types.ttcn, line 13587 */
const_c__AVP__Code__PCC__3GPP__Access__Network__Charging__Identifier__Gx.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Access__Network__Charging__Identifier__Gx;
current_location.update_lineno(13589);
/* DIAMETER_Types.ttcn, line 13589 */
const_c__AVP__Code__AAA__3GPP__Age__Of__Location__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Age__Of__Location__Information;
current_location.update_lineno(13591);
/* DIAMETER_Types.ttcn, line 13591 */
const_c__AVP__Code__DCA__3GPP__PoC__Group__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__Group__Name;
current_location.update_lineno(13593);
/* DIAMETER_Types.ttcn, line 13593 */
const_c__AVP__Code__RX__3GPP__Extended__Max__Requested__BW__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Extended__Max__Requested__BW__DL;
current_location.update_lineno(13595);
/* DIAMETER_Types.ttcn, line 13595 */
const_c__AVP__Code__PCC__3GPP__Flow__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Flow__Information;
current_location.update_lineno(13597);
/* DIAMETER_Types.ttcn, line 13597 */
const_c__AVP__Code__DCA__3GPP__PS__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PS__Information;
current_location.update_lineno(13599);
/* DIAMETER_Types.ttcn, line 13599 */
const_c__AVP__Code__DCA__3GPP__MTC__IWF__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MTC__IWF__Address;
current_location.update_lineno(13601);
/* DIAMETER_Types.ttcn, line 13601 */
const_c__AVP__Code__PCC__3GPP__Execution__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Execution__Time;
current_location.update_lineno(13603);
/* DIAMETER_Types.ttcn, line 13603 */
const_c__AVP__Code__DNAS__NONE__NAS__Identifier.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__NAS__Identifier;
current_location.update_lineno(13605);
/* DIAMETER_Types.ttcn, line 13605 */
const_c__AVP__Code__DNAS__NONE__Tunnel__Server__Auth__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunnel__Server__Auth__Id;
current_location.update_lineno(13607);
/* DIAMETER_Types.ttcn, line 13607 */
const_c__AVP__Code__CxDx__3GPP__Contact.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Contact;
current_location.update_lineno(13609);
/* DIAMETER_Types.ttcn, line 13609 */
const_c__AVP__Code__PCC__3GPP__Charging__Correlation__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Charging__Correlation__Indicator;
current_location.update_lineno(13611);
/* DIAMETER_Types.ttcn, line 13611 */
const_c__AVP__Code__DCC__NONE__Credit__Control.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Credit__Control;
current_location.update_lineno(13613);
/* DIAMETER_Types.ttcn, line 13613 */
const_c__AVP__Code__BASE__NONE__Accounting__Record__Number.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Accounting__Record__Number;
current_location.update_lineno(13615);
/* DIAMETER_Types.ttcn, line 13615 */
const_c__AVP__Code__AAA__3GPP__Event__Threshold__Event__1I.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Event__Threshold__Event__1I;
current_location.update_lineno(13617);
/* DIAMETER_Types.ttcn, line 13617 */
const_c__AVP__Code__DCA__3GPP__SIP__Request__Timestamp__Fraction.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SIP__Request__Timestamp__Fraction;
current_location.update_lineno(13619);
/* DIAMETER_Types.ttcn, line 13619 */
const_c__AVP__Code__DCA__3GPP__Service__Mode.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Service__Mode;
current_location.update_lineno(13621);
/* DIAMETER_Types.ttcn, line 13621 */
const_c__AVP__Code__CxDx__3GPP__User__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__User__Data;
current_location.update_lineno(13623);
/* DIAMETER_Types.ttcn, line 13623 */
const_c__AVP__Code__AAA__3GPP__Report__Interval.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Report__Interval;
current_location.update_lineno(13625);
/* DIAMETER_Types.ttcn, line 13625 */
const_c__AVP__Code__PCC__3GPP__RAN__NAS__Release__Cause.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__RAN__NAS__Release__Cause;
current_location.update_lineno(13627);
/* DIAMETER_Types.ttcn, line 13627 */
const_c__AVP__Code__DCA__3GPP__Dynamic__Address__Flag__Extension.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Dynamic__Address__Flag__Extension;
current_location.update_lineno(13629);
/* DIAMETER_Types.ttcn, line 13629 */
const_c__AVP__Code__AAA__3GPP__Client__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Client__Identity;
current_location.update_lineno(13631);
/* DIAMETER_Types.ttcn, line 13631 */
const_c__AVP__Code__BASE__NONE__Redirect__Host__Usage.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Redirect__Host__Usage;
current_location.update_lineno(13633);
/* DIAMETER_Types.ttcn, line 13633 */
const_c__AVP__Code__DCA__3GPP__CSG__Access__Mode.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__CSG__Access__Mode;
current_location.update_lineno(13635);
/* DIAMETER_Types.ttcn, line 13635 */
const_c__AVP__Code__AAA__3GPP__Equipment__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Equipment__Status;
current_location.update_lineno(13637);
/* DIAMETER_Types.ttcn, line 13637 */
const_c__AVP__Code__DCA__3GPP__Supplementary__Service.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Supplementary__Service;
current_location.update_lineno(13639);
/* DIAMETER_Types.ttcn, line 13639 */
const_c__AVP__Code__GI__3GPP__3GPP__Packet__Filter.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__Packet__Filter;
current_location.update_lineno(13641);
/* DIAMETER_Types.ttcn, line 13641 */
const_c__AVP__Code__DCC__NONE__Redirect__Server__Address.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Redirect__Server__Address;
current_location.update_lineno(13643);
/* DIAMETER_Types.ttcn, line 13643 */
const_c__AVP__Code__MIPv6__NONE__MIP6__Auth__Mode.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__MIP6__Auth__Mode;
current_location.update_lineno(13645);
/* DIAMETER_Types.ttcn, line 13645 */
const_c__AVP__Code__AAA__3GPP__EPS__Location__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__EPS__Location__Information;
current_location.update_lineno(13647);
/* DIAMETER_Types.ttcn, line 13647 */
const_c__AVP__Code__DCA__3GPP__Access__Network__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Access__Network__Information;
current_location.update_lineno(13649);
/* DIAMETER_Types.ttcn, line 13649 */
const_c__AVP__Code__DCA__3GPP__Called__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Called__Identity;
current_location.update_lineno(13651);
/* DIAMETER_Types.ttcn, line 13651 */
const_c__AVP__Code__AAA__3GPP__TWAN__Default__APN__Context__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__TWAN__Default__APN__Context__Id;
current_location.update_lineno(13653);
/* DIAMETER_Types.ttcn, line 13653 */
const_c__AVP__Code__DCA__3GPP__SGSN__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SGSN__Address;
current_location.update_lineno(13655);
/* DIAMETER_Types.ttcn, line 13655 */
const_c__AVP__Code__DCA__3GPP__SGi__PtP__Tunnelling__Method.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SGi__PtP__Tunnelling__Method;
current_location.update_lineno(13657);
/* DIAMETER_Types.ttcn, line 13657 */
const_c__AVP__Code__BASE__NONE__Session__Timeout.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Session__Timeout;
current_location.update_lineno(13659);
/* DIAMETER_Types.ttcn, line 13659 */
const_c__AVP__Code__DNAS__NONE__Acct__Tunnel__Packets__Lost.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Acct__Tunnel__Packets__Lost;
current_location.update_lineno(13661);
/* DIAMETER_Types.ttcn, line 13661 */
const_c__AVP__Code__DCA__3GPP__NNI__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__NNI__Type;
current_location.update_lineno(13663);
/* DIAMETER_Types.ttcn, line 13663 */
const_c__AVP__Code__RX__3GPP__Service__Info__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Service__Info__Status;
current_location.update_lineno(13665);
/* DIAMETER_Types.ttcn, line 13665 */
const_c__AVP__Code__S6__3GPP__CIR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__CIR__Flags;
current_location.update_lineno(13667);
/* DIAMETER_Types.ttcn, line 13667 */
const_c__AVP__Code__PCC__3GPP__Precedence.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Precedence;
current_location.update_lineno(13669);
/* DIAMETER_Types.ttcn, line 13669 */
const_c__AVP__Code__DCA__3GPP__User__Participating__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__User__Participating__Type;
current_location.update_lineno(13671);
/* DIAMETER_Types.ttcn, line 13671 */
const_c__AVP__Code__DCA__3GPP__GGSN__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__GGSN__Address;
current_location.update_lineno(13673);
/* DIAMETER_Types.ttcn, line 13673 */
const_c__AVP__Code__RX__3GPP__Sponsoring__Action.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Sponsoring__Action;
current_location.update_lineno(13675);
/* DIAMETER_Types.ttcn, line 13675 */
const_c__AVP__Code__DCA__3GPP__Radio__Resources__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Radio__Resources__Indicator;
current_location.update_lineno(13677);
/* DIAMETER_Types.ttcn, line 13677 */
const_c__AVP__Code__S6__3GPP__Granted__Validity__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Granted__Validity__Time;
current_location.update_lineno(13679);
/* DIAMETER_Types.ttcn, line 13679 */
const_c__AVP__Code__PCC__3GPP__Priority__Level.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Priority__Level;
current_location.update_lineno(13681);
/* DIAMETER_Types.ttcn, line 13681 */
const_c__AVP__Code__DCA__3GPP__Node__Functionality.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Node__Functionality;
current_location.update_lineno(13683);
/* DIAMETER_Types.ttcn, line 13683 */
const_c__AVP__Code__RX__3GPP__Flow__Description.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Flow__Description;
current_location.update_lineno(13685);
/* DIAMETER_Types.ttcn, line 13685 */
const_c__AVP__Code__PCC__3GPP__Packet__Filter__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Packet__Filter__Information;
current_location.update_lineno(13687);
/* DIAMETER_Types.ttcn, line 13687 */
const_c__AVP__Code__AAA__3GPP__Daylight__Saving__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Daylight__Saving__Time;
current_location.update_lineno(13689);
/* DIAMETER_Types.ttcn, line 13689 */
const_c__AVP__Code__DCA__3GPP__Address__Domain.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Address__Domain;
current_location.update_lineno(13691);
/* DIAMETER_Types.ttcn, line 13691 */
const_c__AVP__Code__S6__3GPP__SCEF__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__SCEF__ID;
current_location.update_lineno(13693);
/* DIAMETER_Types.ttcn, line 13693 */
const_c__AVP__Code__DCA__3GPP__Content__Length.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Content__Length;
current_location.update_lineno(13695);
/* DIAMETER_Types.ttcn, line 13695 */
const_c__AVP__Code__PCC__3GPP__Removal__Of__Access.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Removal__Of__Access;
current_location.update_lineno(13697);
/* DIAMETER_Types.ttcn, line 13697 */
const_c__AVP__Code__PCC__3GPP__ADC__Rule__Report.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__ADC__Rule__Report;
current_location.update_lineno(13699);
/* DIAMETER_Types.ttcn, line 13699 */
const_c__AVP__Code__AAA__3GPP__Preferred__Data__Mode.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Preferred__Data__Mode;
current_location.update_lineno(13701);
/* DIAMETER_Types.ttcn, line 13701 */
const_c__AVP__Code__DCA__3GPP__ProSe__Functionality.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Functionality;
current_location.update_lineno(13703);
/* DIAMETER_Types.ttcn, line 13703 */
const_c__AVP__Code__DCA__3GPP__Low__Balance__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Low__Balance__Indication;
current_location.update_lineno(13705);
/* DIAMETER_Types.ttcn, line 13705 */
const_c__AVP__Code__PCC__3GPP__Guaranteed__Bitrate__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Guaranteed__Bitrate__UL;
current_location.update_lineno(13707);
/* DIAMETER_Types.ttcn, line 13707 */
const_c__AVP__Code__AAA__3GPP__UE__SRVCC__Capability.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__UE__SRVCC__Capability;
current_location.update_lineno(13709);
/* DIAMETER_Types.ttcn, line 13709 */
const_c__AVP__Code__DNAS__NONE__Login__LAT__Group.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Login__LAT__Group;
current_location.update_lineno(13711);
/* DIAMETER_Types.ttcn, line 13711 */
const_c__AVP__Code__DNAS__NONE__NAS__IPv6__Address.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__NAS__IPv6__Address;
current_location.update_lineno(13713);
/* DIAMETER_Types.ttcn, line 13713 */
const_c__AVP__Code__MIPv6__NONE__MIP__MAC__Mobility__Data.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__MIP__MAC__Mobility__Data;
current_location.update_lineno(13715);
/* DIAMETER_Types.ttcn, line 13715 */
const_c__AVP__Code__MIPv4__NONE__Accounting__Output__Octets.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__Accounting__Output__Octets;
current_location.update_lineno(13717);
/* DIAMETER_Types.ttcn, line 13717 */
const_c__AVP__Code__CxDx__3GPP__To__SIP__Header.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__To__SIP__Header;
current_location.update_lineno(13719);
/* DIAMETER_Types.ttcn, line 13719 */
const_c__AVP__Code__AAA__3GPP__Coupled__Node__Diameter__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Coupled__Node__Diameter__ID;
current_location.update_lineno(13721);
/* DIAMETER_Types.ttcn, line 13721 */
const_c__AVP__Code__DCA__3GPP__Real__Time__Tariff__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Real__Time__Tariff__Information;
current_location.update_lineno(13723);
/* DIAMETER_Types.ttcn, line 13723 */
const_c__AVP__Code__AAA__3GPP__STN__SR.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__STN__SR;
current_location.update_lineno(13725);
/* DIAMETER_Types.ttcn, line 13725 */
const_c__AVP__Code__DCA__3GPP__SDP__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SDP__Type;
current_location.update_lineno(13727);
/* DIAMETER_Types.ttcn, line 13727 */
const_c__AVP__Code__BASE__NONE__Supported__Vendor__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Supported__Vendor__Id;
current_location.update_lineno(13729);
/* DIAMETER_Types.ttcn, line 13729 */
const_c__AVP__Code__AAA__3GPP__ServiceTypeIdentity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__ServiceTypeIdentity;
current_location.update_lineno(13731);
/* DIAMETER_Types.ttcn, line 13731 */
const_c__AVP__Code__DCA__3GPP__Requested__Party__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Requested__Party__Address;
current_location.update_lineno(13733);
/* DIAMETER_Types.ttcn, line 13733 */
const_c__AVP__Code__DCA__3GPP__Announcement__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Announcement__Information;
current_location.update_lineno(13735);
/* DIAMETER_Types.ttcn, line 13735 */
const_c__AVP__Code__DNAS__NONE__Acct__Authentic.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Acct__Authentic;
current_location.update_lineno(13737);
/* DIAMETER_Types.ttcn, line 13737 */
const_c__AVP__Code__DCC__NONE__Service__Identifier.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Service__Identifier;
current_location.update_lineno(13739);
/* DIAMETER_Types.ttcn, line 13739 */
const_c__AVP__Code__AAA__3GPP__AUTN.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__AUTN;
current_location.update_lineno(13741);
/* DIAMETER_Types.ttcn, line 13741 */
const_c__AVP__Code__AAA__3GPP__Non__3GPP__User__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Non__3GPP__User__Data;
current_location.update_lineno(13743);
/* DIAMETER_Types.ttcn, line 13743 */
const_c__AVP__Code__DCA__3GPP__Delivery__Report__Requested.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Delivery__Report__Requested;
current_location.update_lineno(13745);
/* DIAMETER_Types.ttcn, line 13745 */
const_c__AVP__Code__GI__3GPP__TWAN__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__TWAN__Identifier;
current_location.update_lineno(13747);
/* DIAMETER_Types.ttcn, line 13747 */
const_c__AVP__Code__AAA__3GPP__Origination__Time__Stamp.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Origination__Time__Stamp;
current_location.update_lineno(13749);
/* DIAMETER_Types.ttcn, line 13749 */
const_c__AVP__Code__DCA__3GPP__LCS__APN.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__APN;
current_location.update_lineno(13751);
/* DIAMETER_Types.ttcn, line 13751 */
const_c__AVP__Code__DCA__3GPP__Envelope__End__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Envelope__End__Time;
current_location.update_lineno(13753);
/* DIAMETER_Types.ttcn, line 13753 */
const_c__AVP__Code__RX__3GPP__Sponsored__Connectivity__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Sponsored__Connectivity__Data;
current_location.update_lineno(13755);
/* DIAMETER_Types.ttcn, line 13755 */
const_c__AVP__Code__BASE__NONE__Auth__Request__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Auth__Request__Type;
current_location.update_lineno(13757);
/* DIAMETER_Types.ttcn, line 13757 */
const_c__AVP__Code__DCA__3GPP__Application__Server__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Application__Server__Information;
current_location.update_lineno(13759);
/* DIAMETER_Types.ttcn, line 13759 */
const_c__AVP__Code__DCA__3GPP__Originator__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Originator__Address;
current_location.update_lineno(13761);
/* DIAMETER_Types.ttcn, line 13761 */
const_c__AVP__Code__DCA__3GPP__Network__Call__Reference__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Network__Call__Reference__Number;
current_location.update_lineno(13763);
/* DIAMETER_Types.ttcn, line 13763 */
const_c__AVP__Code__S6__3GPP__AESE__Communication__Pattern.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__AESE__Communication__Pattern;
current_location.update_lineno(13765);
/* DIAMETER_Types.ttcn, line 13765 */
const_c__AVP__Code__PCC__3GPP__NBIFOM__Mode.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__NBIFOM__Mode;
current_location.update_lineno(13767);
/* DIAMETER_Types.ttcn, line 13767 */
const_c__AVP__Code__PCC__3GPP__Redirect__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Redirect__Information;
current_location.update_lineno(13769);
/* DIAMETER_Types.ttcn, line 13769 */
const_c__AVP__Code__DCC__NONE__Validity__Time.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Validity__Time;
current_location.update_lineno(13771);
/* DIAMETER_Types.ttcn, line 13771 */
const_c__AVP__Code__DCA__3GPP__Monitoring__UE__VPLMN__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Monitoring__UE__VPLMN__Identifier;
current_location.update_lineno(13773);
/* DIAMETER_Types.ttcn, line 13773 */
const_c__AVP__Code__S6__3GPP__Event__Handling.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Event__Handling;
current_location.update_lineno(13775);
/* DIAMETER_Types.ttcn, line 13775 */
const_c__AVP__Code__PCC__3GPP__ToS__Traffic__Class.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__ToS__Traffic__Class;
current_location.update_lineno(13777);
/* DIAMETER_Types.ttcn, line 13777 */
const_c__AVP__Code__AAA__3GPP__Tracking__Area__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Tracking__Area__Identity;
current_location.update_lineno(13779);
/* DIAMETER_Types.ttcn, line 13779 */
const_c__AVP__Code__MIPv4__NONE__MIP__HA__to__FA__SPI.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__HA__to__FA__SPI;
current_location.update_lineno(13781);
/* DIAMETER_Types.ttcn, line 13781 */
const_c__AVP__Code__RX__3GPP__Min__Desired__Bandwidth__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Min__Desired__Bandwidth__UL;
current_location.update_lineno(13783);
/* DIAMETER_Types.ttcn, line 13783 */
const_c__AVP__Code__AAA__3GPP__UVR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__UVR__Flags;
current_location.update_lineno(13785);
/* DIAMETER_Types.ttcn, line 13785 */
const_c__AVP__Code__DCA__3GPP__PS__Free__Format__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PS__Free__Format__Data;
current_location.update_lineno(13787);
/* DIAMETER_Types.ttcn, line 13787 */
const_c__AVP__Code__CxDx__3GPP__Originating__Request.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Originating__Request;
current_location.update_lineno(13789);
/* DIAMETER_Types.ttcn, line 13789 */
const_c__AVP__Code__PCC__3GPP__PDN__Connection__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__PDN__Connection__ID;
current_location.update_lineno(13791);
/* DIAMETER_Types.ttcn, line 13791 */
const_c__AVP__Code__AAA__3GPP__Subscription__Data__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Subscription__Data__Flags;
current_location.update_lineno(13793);
/* DIAMETER_Types.ttcn, line 13793 */
const_c__AVP__Code__DNAS__NONE__Framed__IPv6__Route.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__IPv6__Route;
current_location.update_lineno(13795);
/* DIAMETER_Types.ttcn, line 13795 */
const_c__AVP__Code__PCC__3GPP__PRA__Remove.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__PRA__Remove;
current_location.update_lineno(13797);
/* DIAMETER_Types.ttcn, line 13797 */
const_c__AVP__Code__AAA__3GPP__DSR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__DSR__Flags;
current_location.update_lineno(13799);
/* DIAMETER_Types.ttcn, line 13799 */
const_c__AVP__Code__DCC__NONE__Granted__Service__Unit.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Granted__Service__Unit;
current_location.update_lineno(13801);
/* DIAMETER_Types.ttcn, line 13801 */
const_c__AVP__Code__MIPv6__NONE__MIP__Timestamp.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__MIP__Timestamp;
current_location.update_lineno(13803);
/* DIAMETER_Types.ttcn, line 13803 */
const_c__AVP__Code__DCA__3GPP__Number__Portability__Routing__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Number__Portability__Routing__Information;
current_location.update_lineno(13805);
/* DIAMETER_Types.ttcn, line 13805 */
const_c__AVP__Code__AAA__3GPP__Subscribed__Periodic__RAU__TAU__Timer.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Subscribed__Periodic__RAU__TAU__Timer;
current_location.update_lineno(13807);
/* DIAMETER_Types.ttcn, line 13807 */
const_c__AVP__Code__AAA__3GPP__Specific__APN__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Specific__APN__Info;
current_location.update_lineno(13809);
/* DIAMETER_Types.ttcn, line 13809 */
const_c__AVP__Code__AAA__3GPP__Terminal__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Terminal__Information;
current_location.update_lineno(13811);
/* DIAMETER_Types.ttcn, line 13811 */
const_c__AVP__Code__CxDx__3GPP__Restoration__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Restoration__Info;
current_location.update_lineno(13813);
/* DIAMETER_Types.ttcn, line 13813 */
const_c__AVP__Code__BASE__NONE__Product__Name.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Product__Name;
current_location.update_lineno(13815);
/* DIAMETER_Types.ttcn, line 13815 */
const_c__AVP__Code__MIPv4__NONE__MIP__HA__to__MN__MSA.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__HA__to__MN__MSA;
current_location.update_lineno(13817);
/* DIAMETER_Types.ttcn, line 13817 */
const_c__AVP__Code__DCA__3GPP__Account__Expiration.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Account__Expiration;
current_location.update_lineno(13819);
/* DIAMETER_Types.ttcn, line 13819 */
const_c__AVP__Code__AAA__3GPP__CSG__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__CSG__Id;
current_location.update_lineno(13821);
/* DIAMETER_Types.ttcn, line 13821 */
const_c__AVP__Code__DNAS__NONE__Framed__IP__Netmask.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__IP__Netmask;
current_location.update_lineno(13823);
/* DIAMETER_Types.ttcn, line 13823 */
const_c__AVP__Code__GI__3GPP__3GPP__IPv6__DNS__Servers.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__IPv6__DNS__Servers;
current_location.update_lineno(13825);
/* DIAMETER_Types.ttcn, line 13825 */
const_c__AVP__Code__AAA__3GPP__SSID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SSID;
current_location.update_lineno(13827);
/* DIAMETER_Types.ttcn, line 13827 */
const_c__AVP__Code__AAA__3GPP__Call__Barring__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Call__Barring__Info;
current_location.update_lineno(13829);
/* DIAMETER_Types.ttcn, line 13829 */
const_c__AVP__Code__DCA__3GPP__BSSID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__BSSID;
current_location.update_lineno(13831);
/* DIAMETER_Types.ttcn, line 13831 */
const_c__AVP__Code__DCC__NONE__Service__Parameter__Info.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Service__Parameter__Info;
current_location.update_lineno(13833);
/* DIAMETER_Types.ttcn, line 13833 */
const_c__AVP__Code__DCA__3GPP__Talk__Burst__Exchange.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Talk__Burst__Exchange;
current_location.update_lineno(13835);
/* DIAMETER_Types.ttcn, line 13835 */
const_c__AVP__Code__DCA__3GPP__Variable__Part__Order.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Variable__Part__Order;
current_location.update_lineno(13837);
/* DIAMETER_Types.ttcn, line 13837 */
const_c__AVP__Code__DCA__3GPP__Time__Quota__Mechanism.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Time__Quota__Mechanism;
current_location.update_lineno(13839);
/* DIAMETER_Types.ttcn, line 13839 */
const_c__AVP__Code__AAA__3GPP__ANID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__ANID;
current_location.update_lineno(13841);
/* DIAMETER_Types.ttcn, line 13841 */
const_c__AVP__Code__DCA__3GPP__Monitoring__Event__Report__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Monitoring__Event__Report__Number;
current_location.update_lineno(13843);
/* DIAMETER_Types.ttcn, line 13843 */
const_c__AVP__Code__S6__3GPP__IP__SM__GW__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__IP__SM__GW__Name;
current_location.update_lineno(13845);
/* DIAMETER_Types.ttcn, line 13845 */
const_c__AVP__Code__BASE__NONE__Origin__State__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Origin__State__Id;
current_location.update_lineno(13847);
/* DIAMETER_Types.ttcn, line 13847 */
const_c__AVP__Code__RX__3GPP__Media__Sub__Component.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Media__Sub__Component;
current_location.update_lineno(13849);
/* DIAMETER_Types.ttcn, line 13849 */
const_c__AVP__Code__DCA__3GPP__CN__Operator__Selection__Entity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__CN__Operator__Selection__Entity;
current_location.update_lineno(13851);
/* DIAMETER_Types.ttcn, line 13851 */
const_c__AVP__Code__S6__3GPP__Accuracy.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Accuracy;
current_location.update_lineno(13853);
/* DIAMETER_Types.ttcn, line 13853 */
const_c__AVP__Code__PCC__3GPP__Charging__Rule__Remove.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Charging__Rule__Remove;
current_location.update_lineno(13855);
/* DIAMETER_Types.ttcn, line 13855 */
const_c__AVP__Code__DCA__3GPP__Originating__IOI.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Originating__IOI;
current_location.update_lineno(13857);
/* DIAMETER_Types.ttcn, line 13857 */
const_c__AVP__Code__RX__3GPP__Min__Requested__Bandwidth__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Min__Requested__Bandwidth__DL;
current_location.update_lineno(13859);
/* DIAMETER_Types.ttcn, line 13859 */
const_c__AVP__Code__DCA__3GPP__ProSe__Function__PLMN__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Function__PLMN__Identifier;
current_location.update_lineno(13861);
/* DIAMETER_Types.ttcn, line 13861 */
const_c__AVP__Code__S6__3GPP__Service__Report.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Service__Report;
current_location.update_lineno(13863);
/* DIAMETER_Types.ttcn, line 13863 */
const_c__AVP__Code__PCC__3GPP__Tunnel__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Tunnel__Information;
current_location.update_lineno(13865);
/* DIAMETER_Types.ttcn, line 13865 */
const_c__AVP__Code__DCA__3GPP__Bearer__Service.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Bearer__Service;
current_location.update_lineno(13867);
/* DIAMETER_Types.ttcn, line 13867 */
const_c__AVP__Code__CxDx__3GPP__Primary__Charging__Collection__Function__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Primary__Charging__Collection__Function__Name;
current_location.update_lineno(13869);
/* DIAMETER_Types.ttcn, line 13869 */
const_c__AVP__Code__PCC__3GPP__QoS__Rule__Definition.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__QoS__Rule__Definition;
current_location.update_lineno(13871);
/* DIAMETER_Types.ttcn, line 13871 */
const_c__AVP__Code__AAA__3GPP__Time__Zone.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Time__Zone;
current_location.update_lineno(13873);
/* DIAMETER_Types.ttcn, line 13873 */
const_c__AVP__Code__S6__3GPP__Periodic__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Periodic__Time;
current_location.update_lineno(13875);
/* DIAMETER_Types.ttcn, line 13875 */
const_c__AVP__Code__PCC__3GPP__Routing__Rule__Failure__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Routing__Rule__Failure__Code;
current_location.update_lineno(13877);
/* DIAMETER_Types.ttcn, line 13877 */
const_c__AVP__Code__PCC__3GPP__TDF__Destination__Host.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__TDF__Destination__Host;
current_location.update_lineno(13879);
/* DIAMETER_Types.ttcn, line 13879 */
const_c__AVP__Code__AAA__3GPP__Local__Group__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Local__Group__Id;
current_location.update_lineno(13881);
/* DIAMETER_Types.ttcn, line 13881 */
const_c__AVP__Code__DCA__3GPP__SM__Discharge__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SM__Discharge__Time;
current_location.update_lineno(13883);
/* DIAMETER_Types.ttcn, line 13883 */
const_c__AVP__Code__DCA__3GPP__Requestor__PLMN__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Requestor__PLMN__Identifier;
current_location.update_lineno(13885);
/* DIAMETER_Types.ttcn, line 13885 */
const_c__AVP__Code__DCA__3GPP__IMS__Application__Reference__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__IMS__Application__Reference__Identifier;
current_location.update_lineno(13887);
/* DIAMETER_Types.ttcn, line 13887 */
const_c__AVP__Code__PCC__3GPP__Charging__Rule__Report.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Charging__Rule__Report;
current_location.update_lineno(13889);
/* DIAMETER_Types.ttcn, line 13889 */
const_c__AVP__Code__AAA__3GPP__Service__Area__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Service__Area__Identity;
current_location.update_lineno(13891);
/* DIAMETER_Types.ttcn, line 13891 */
const_c__AVP__Code__BASE__NONE__User__Name.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__User__Name;
current_location.update_lineno(13893);
/* DIAMETER_Types.ttcn, line 13893 */
const_c__AVP__Code__AAA__3GPP__UE__PC5__AMBR.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__UE__PC5__AMBR;
current_location.update_lineno(13895);
/* DIAMETER_Types.ttcn, line 13895 */
const_c__AVP__Code__CxDx__3GPP__Public__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Public__Identity;
current_location.update_lineno(13897);
/* DIAMETER_Types.ttcn, line 13897 */
const_c__AVP__Code__BASE__NONE__Accounting__Sub__Session__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Accounting__Sub__Session__Id;
current_location.update_lineno(13899);
/* DIAMETER_Types.ttcn, line 13899 */
const_c__AVP__Code__DNAS__NONE__Acct__Delay__Time.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Acct__Delay__Time;
current_location.update_lineno(13901);
/* DIAMETER_Types.ttcn, line 13901 */
const_c__AVP__Code__DCA__3GPP__Local__Sequence__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Local__Sequence__Number;
current_location.update_lineno(13903);
/* DIAMETER_Types.ttcn, line 13903 */
const_c__AVP__Code__CxDx__3GPP__UAR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__UAR__Flags;
current_location.update_lineno(13905);
/* DIAMETER_Types.ttcn, line 13905 */
const_c__AVP__Code__AAA__3GPP__Collection__Period__RRM__UMTS.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Collection__Period__RRM__UMTS;
current_location.update_lineno(13907);
/* DIAMETER_Types.ttcn, line 13907 */
const_c__AVP__Code__AAA__3GPP__Operator__Determined__Barring.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Operator__Determined__Barring;
current_location.update_lineno(13909);
/* DIAMETER_Types.ttcn, line 13909 */
const_c__AVP__Code__DCA__3GPP__Recipient__Received__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Recipient__Received__Address;
current_location.update_lineno(13911);
/* DIAMETER_Types.ttcn, line 13911 */
const_c__AVP__Code__DNAS__NONE__Tunnel__Server__Endpoint.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunnel__Server__Endpoint;
current_location.update_lineno(13913);
/* DIAMETER_Types.ttcn, line 13913 */
const_c__AVP__Code__MIPv4__NONE__MIP__Candidate__Home__Agent__Host.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Candidate__Home__Agent__Host;
current_location.update_lineno(13915);
/* DIAMETER_Types.ttcn, line 13915 */
const_c__AVP__Code__BASE__NONE__Session__Binding.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Session__Binding;
current_location.update_lineno(13917);
/* DIAMETER_Types.ttcn, line 13917 */
const_c__AVP__Code__GI__3GPP__3GPP__IMEISV.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__IMEISV;
current_location.update_lineno(13919);
/* DIAMETER_Types.ttcn, line 13919 */
const_c__AVP__Code__AAA__3GPP__SS__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SS__Code;
current_location.update_lineno(13921);
/* DIAMETER_Types.ttcn, line 13921 */
const_c__AVP__Code__DCA__3GPP__DCD__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__DCD__Information;
current_location.update_lineno(13923);
/* DIAMETER_Types.ttcn, line 13923 */
const_c__AVP__Code__DCA__3GPP__Location__Estimate__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Location__Estimate__Type;
current_location.update_lineno(13925);
/* DIAMETER_Types.ttcn, line 13925 */
const_c__AVP__Code__DCA__3GPP__Time__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Time__Indicator;
current_location.update_lineno(13927);
/* DIAMETER_Types.ttcn, line 13927 */
const_c__AVP__Code__DCA__3GPP__Addressee__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Addressee__Type;
current_location.update_lineno(13929);
/* DIAMETER_Types.ttcn, line 13929 */
const_c__AVP__Code__BASE__NONE__Acct__Multi__Session__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Acct__Multi__Session__Id;
current_location.update_lineno(13931);
/* DIAMETER_Types.ttcn, line 13931 */
const_c__AVP__Code__DCC__NONE__Subscription__Id__Data.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Subscription__Id__Data;
current_location.update_lineno(13933);
/* DIAMETER_Types.ttcn, line 13933 */
const_c__AVP__Code__AAA__3GPP__TWAN__Connectivity__Parameters.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__TWAN__Connectivity__Parameters;
current_location.update_lineno(13935);
/* DIAMETER_Types.ttcn, line 13935 */
const_c__AVP__Code__DCA__3GPP__Reply__Applic__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Reply__Applic__ID;
current_location.update_lineno(13937);
/* DIAMETER_Types.ttcn, line 13937 */
const_c__AVP__Code__DCA__3GPP__Participant__Access__Priority.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Participant__Access__Priority;
current_location.update_lineno(13939);
/* DIAMETER_Types.ttcn, line 13939 */
const_c__AVP__Code__RX__3GPP__RS__Bandwidth.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__RS__Bandwidth;
current_location.update_lineno(13941);
/* DIAMETER_Types.ttcn, line 13941 */
const_c__AVP__Code__S6__3GPP__Reachability__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Reachability__Information;
current_location.update_lineno(13943);
/* DIAMETER_Types.ttcn, line 13943 */
const_c__AVP__Code__MIPv4__NONE__MIP__Algorithm__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Algorithm__Type;
current_location.update_lineno(13945);
/* DIAMETER_Types.ttcn, line 13945 */
const_c__AVP__Code__DCA__3GPP__SDP__Session__Description.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SDP__Session__Description;
current_location.update_lineno(13947);
/* DIAMETER_Types.ttcn, line 13947 */
const_c__AVP__Code__RX__3GPP__Extended__Min__Desired__BW__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Extended__Min__Desired__BW__DL;
current_location.update_lineno(13949);
/* DIAMETER_Types.ttcn, line 13949 */
const_c__AVP__Code__DCA__3GPP__Location__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Location__Info;
current_location.update_lineno(13951);
/* DIAMETER_Types.ttcn, line 13951 */
const_c__AVP__Code__PCC__3GPP__APN__Aggregate__Max__Bitrate__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__APN__Aggregate__Max__Bitrate__UL;
current_location.update_lineno(13953);
/* DIAMETER_Types.ttcn, line 13953 */
const_c__AVP__Code__AAA__3GPP__Event__Threshold__RSRQ.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Event__Threshold__RSRQ;
current_location.update_lineno(13955);
/* DIAMETER_Types.ttcn, line 13955 */
const_c__AVP__Code__DCA__3GPP__LCS__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Information;
current_location.update_lineno(13957);
/* DIAMETER_Types.ttcn, line 13957 */
const_c__AVP__Code__S6__3GPP__Service__Parameters.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Service__Parameters;
current_location.update_lineno(13959);
/* DIAMETER_Types.ttcn, line 13959 */
const_c__AVP__Code__PCC__3GPP__Presence__Reporting__Area__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Presence__Reporting__Area__Information;
current_location.update_lineno(13961);
/* DIAMETER_Types.ttcn, line 13961 */
const_c__AVP__Code__PCC__3GPP__Routing__Rule__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Routing__Rule__Identifier;
current_location.update_lineno(13963);
/* DIAMETER_Types.ttcn, line 13963 */
const_c__AVP__Code__DCA__3GPP__SMS__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SMS__Information;
current_location.update_lineno(13965);
/* DIAMETER_Types.ttcn, line 13965 */
const_c__AVP__Code__DCA__3GPP__ePDG__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ePDG__Address;
current_location.update_lineno(13967);
/* DIAMETER_Types.ttcn, line 13967 */
const_c__AVP__Code__PCC__3GPP__Event__Trigger.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Event__Trigger;
current_location.update_lineno(13969);
/* DIAMETER_Types.ttcn, line 13969 */
const_c__AVP__Code__RX__3GPP__GCS__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__GCS__Identifier;
current_location.update_lineno(13971);
/* DIAMETER_Types.ttcn, line 13971 */
const_c__AVP__Code__MIPv6__NONE__QoS__Capability.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__QoS__Capability;
current_location.update_lineno(13973);
/* DIAMETER_Types.ttcn, line 13973 */
const_c__AVP__Code__PCC__3GPP__ADC__Rule__Install.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__ADC__Rule__Install;
current_location.update_lineno(13975);
/* DIAMETER_Types.ttcn, line 13975 */
const_c__AVP__Code__AAA__3GPP__Non__IP__PDN__Type__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Non__IP__PDN__Type__Indicator;
current_location.update_lineno(13977);
/* DIAMETER_Types.ttcn, line 13977 */
const_c__AVP__Code__DCC__NONE__G__S__U__Pool__Identifier.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__G__S__U__Pool__Identifier;
current_location.update_lineno(13979);
/* DIAMETER_Types.ttcn, line 13979 */
const_c__AVP__Code__DCA__3GPP__Outgoing__Session__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Outgoing__Session__Id;
current_location.update_lineno(13981);
/* DIAMETER_Types.ttcn, line 13981 */
const_c__AVP__Code__DCA__3GPP__PoC__Controlling__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__Controlling__Address;
current_location.update_lineno(13983);
/* DIAMETER_Types.ttcn, line 13983 */
const_c__AVP__Code__DCA__3GPP__Dynamic__Address__Flag.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Dynamic__Address__Flag;
current_location.update_lineno(13985);
/* DIAMETER_Types.ttcn, line 13985 */
const_c__AVP__Code__CxDx__3GPP__Confidentiality__Key.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Confidentiality__Key;
current_location.update_lineno(13987);
/* DIAMETER_Types.ttcn, line 13987 */
const_c__AVP__Code__PCC__3GPP__Flow__Label.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Flow__Label;
current_location.update_lineno(13989);
/* DIAMETER_Types.ttcn, line 13989 */
const_c__AVP__Code__DNAS__NONE__NAS__Port.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__NAS__Port;
current_location.update_lineno(13991);
/* DIAMETER_Types.ttcn, line 13991 */
const_c__AVP__Code__AAA__3GPP__Authentication__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Authentication__Info;
current_location.update_lineno(13993);
/* DIAMETER_Types.ttcn, line 13993 */
const_c__AVP__Code__DCA__3GPP__Transcoder__Inserted__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Transcoder__Inserted__Indication;
current_location.update_lineno(13995);
/* DIAMETER_Types.ttcn, line 13995 */
const_c__AVP__Code__DCA__3GPP__SMS__Node.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SMS__Node;
current_location.update_lineno(13997);
/* DIAMETER_Types.ttcn, line 13997 */
const_c__AVP__Code__AAA__3GPP__Trace__Interface__List.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Trace__Interface__List;
current_location.update_lineno(13999);
/* DIAMETER_Types.ttcn, line 13999 */
const_c__AVP__Code__DCA__3GPP__SGW__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SGW__Address;
current_location.update_lineno(14001);
/* DIAMETER_Types.ttcn, line 14001 */
const_c__AVP__Code__GI__3GPP__3GPP__Charging__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__Charging__Id;
current_location.update_lineno(14003);
/* DIAMETER_Types.ttcn, line 14003 */
const_c__AVP__Code__DNAS__NONE__CHAP__Algorithm.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__CHAP__Algorithm;
current_location.update_lineno(14005);
/* DIAMETER_Types.ttcn, line 14005 */
const_c__AVP__Code__AAA__3GPP__APN__Configuration__Profile.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__APN__Configuration__Profile;
current_location.update_lineno(14007);
/* DIAMETER_Types.ttcn, line 14007 */
const_c__AVP__Code__DCA__3GPP__Number__Of__Received__Talk__Bursts.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Number__Of__Received__Talk__Bursts;
current_location.update_lineno(14009);
/* DIAMETER_Types.ttcn, line 14009 */
const_c__AVP__Code__AAA__3GPP__Full__Network__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Full__Network__Name;
current_location.update_lineno(14011);
/* DIAMETER_Types.ttcn, line 14011 */
const_c__AVP__Code__DCA__3GPP__Message__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Message__Type;
current_location.update_lineno(14013);
/* DIAMETER_Types.ttcn, line 14013 */
const_c__AVP__Code__DCA__3GPP__APN__Rate__Control__Uplink.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__APN__Rate__Control__Uplink;
current_location.update_lineno(14015);
/* DIAMETER_Types.ttcn, line 14015 */
const_c__AVP__Code__GI__3GPP__3GPP__CAMEL__Charging__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__CAMEL__Charging__Info;
current_location.update_lineno(14017);
/* DIAMETER_Types.ttcn, line 14017 */
const_c__AVP__Code__DCA__3GPP__From__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__From__Address;
current_location.update_lineno(14019);
/* DIAMETER_Types.ttcn, line 14019 */
const_c__AVP__Code__AAA__3GPP__TWAG__CP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__TWAG__CP__Address;
current_location.update_lineno(14021);
/* DIAMETER_Types.ttcn, line 14021 */
const_c__AVP__Code__DCA__3GPP__PDP__Context__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PDP__Context__Type;
current_location.update_lineno(14023);
/* DIAMETER_Types.ttcn, line 14023 */
const_c__AVP__Code__RX__3GPP__Flows.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Flows;
current_location.update_lineno(14025);
/* DIAMETER_Types.ttcn, line 14025 */
const_c__AVP__Code__DCA__3GPP__User__Session__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__User__Session__Id;
current_location.update_lineno(14027);
/* DIAMETER_Types.ttcn, line 14027 */
const_c__AVP__Code__DCA__3GPP__PoC__Change__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__Change__Time;
current_location.update_lineno(14029);
/* DIAMETER_Types.ttcn, line 14029 */
const_c__AVP__Code__DCA__3GPP__Privacy__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Privacy__Indicator;
current_location.update_lineno(14031);
/* DIAMETER_Types.ttcn, line 14031 */
const_c__AVP__Code__S6__3GPP__CIA__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__CIA__Flags;
current_location.update_lineno(14033);
/* DIAMETER_Types.ttcn, line 14033 */
const_c__AVP__Code__RX__3GPP__Extended__Min__Requested__BW__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Extended__Min__Requested__BW__UL;
current_location.update_lineno(14035);
/* DIAMETER_Types.ttcn, line 14035 */
const_c__AVP__Code__PCC__3GPP__Monitoring__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Monitoring__Time;
current_location.update_lineno(14037);
/* DIAMETER_Types.ttcn, line 14037 */
const_c__AVP__Code__DCC__NONE__CC__Input__Octets.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Input__Octets;
current_location.update_lineno(14039);
/* DIAMETER_Types.ttcn, line 14039 */
const_c__AVP__Code__DCA__3GPP__Teleservice.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Teleservice;
current_location.update_lineno(14041);
/* DIAMETER_Types.ttcn, line 14041 */
const_c__AVP__Code__DCA__3GPP__Quota__Consumption__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Quota__Consumption__Time;
current_location.update_lineno(14043);
/* DIAMETER_Types.ttcn, line 14043 */
const_c__AVP__Code__S6__3GPP__UE__Reachability__Configuration.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__UE__Reachability__Configuration;
current_location.update_lineno(14045);
/* DIAMETER_Types.ttcn, line 14045 */
const_c__AVP__Code__BASE__NONE__Destination__Realm.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Destination__Realm;
current_location.update_lineno(14047);
/* DIAMETER_Types.ttcn, line 14047 */
const_c__AVP__Code__RX__3GPP__Acceptable__Service__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Acceptable__Service__Info;
current_location.update_lineno(14049);
/* DIAMETER_Types.ttcn, line 14049 */
const_c__AVP__Code__PCC__3GPP__Flow__Direction.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Flow__Direction;
current_location.update_lineno(14051);
/* DIAMETER_Types.ttcn, line 14051 */
const_c__AVP__Code__DCA__3GPP__ProSe__Reason__For__Cancellation.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Reason__For__Cancellation;
current_location.update_lineno(14053);
/* DIAMETER_Types.ttcn, line 14053 */
const_c__AVP__Code__S6__3GPP__Supported__Monitoring__Events.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Supported__Monitoring__Events;
current_location.update_lineno(14055);
/* DIAMETER_Types.ttcn, line 14055 */
const_c__AVP__Code__DCA__3GPP__CG__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__CG__Address;
current_location.update_lineno(14057);
/* DIAMETER_Types.ttcn, line 14057 */
const_c__AVP__Code__DCA__3GPP__Radio__Parameter__Set__Values.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Radio__Parameter__Set__Values;
current_location.update_lineno(14059);
/* DIAMETER_Types.ttcn, line 14059 */
const_c__AVP__Code__CxDx__3GPP__SIP__Item__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__SIP__Item__Number;
current_location.update_lineno(14061);
/* DIAMETER_Types.ttcn, line 14061 */
const_c__AVP__Code__PCC__3GPP__Session__Release__Cause.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Session__Release__Cause;
current_location.update_lineno(14063);
/* DIAMETER_Types.ttcn, line 14063 */
const_c__AVP__Code__AAA__3GPP__MDT__User__Consent.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MDT__User__Consent;
current_location.update_lineno(14065);
/* DIAMETER_Types.ttcn, line 14065 */
const_c__AVP__Code__S6__3GPP__HSS__Cause.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__HSS__Cause;
current_location.update_lineno(14067);
/* DIAMETER_Types.ttcn, line 14067 */
const_c__AVP__Code__MIPv6__NONE__MIP6__Home__Link__Prefix.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__MIP6__Home__Link__Prefix;
current_location.update_lineno(14069);
/* DIAMETER_Types.ttcn, line 14069 */
const_c__AVP__Code__DNAS__NONE__Login__LAT__Port.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Login__LAT__Port;
current_location.update_lineno(14071);
/* DIAMETER_Types.ttcn, line 14071 */
const_c__AVP__Code__PCC__3GPP__PCSCF__Restoration__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__PCSCF__Restoration__Indication;
current_location.update_lineno(14073);
/* DIAMETER_Types.ttcn, line 14073 */
const_c__AVP__Code__DCC__NONE__G__S__U__Pool__Reference.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__G__S__U__Pool__Reference;
current_location.update_lineno(14075);
/* DIAMETER_Types.ttcn, line 14075 */
const_c__AVP__Code__DCA__3GPP__Layer__2__Group__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Layer__2__Group__ID;
current_location.update_lineno(14077);
/* DIAMETER_Types.ttcn, line 14077 */
const_c__AVP__Code__DCA__3GPP__Interface__Port.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Interface__Port;
current_location.update_lineno(14079);
/* DIAMETER_Types.ttcn, line 14079 */
const_c__AVP__Code__AAA__3GPP__Subscription__Data__Deletion.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Subscription__Data__Deletion;
current_location.update_lineno(14081);
/* DIAMETER_Types.ttcn, line 14081 */
const_c__AVP__Code__MIPv6__NONE__Chargable__User__Identity.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__Chargable__User__Identity;
current_location.update_lineno(14083);
/* DIAMETER_Types.ttcn, line 14083 */
const_c__AVP__Code__AAA__3GPP__Trace__Collection__Entity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Trace__Collection__Entity;
current_location.update_lineno(14085);
/* DIAMETER_Types.ttcn, line 14085 */
const_c__AVP__Code__DCA__3GPP__AoC__Request__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__AoC__Request__Type;
current_location.update_lineno(14087);
/* DIAMETER_Types.ttcn, line 14087 */
const_c__AVP__Code__CxDx__3GPP__Feature__List__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Feature__List__ID;
current_location.update_lineno(14089);
/* DIAMETER_Types.ttcn, line 14089 */
const_c__AVP__Code__BASE__NONE__Redirect__Host.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Redirect__Host;
current_location.update_lineno(14091);
/* DIAMETER_Types.ttcn, line 14091 */
const_c__AVP__Code__AAA__3GPP__Network__Access__Mode.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Network__Access__Mode;
current_location.update_lineno(14093);
/* DIAMETER_Types.ttcn, line 14093 */
const_c__AVP__Code__DNAS__NONE__Framed__Compression.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__Compression;
current_location.update_lineno(14095);
/* DIAMETER_Types.ttcn, line 14095 */
const_c__AVP__Code__DNAS__NONE__ARAP__Zone__Access.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__ARAP__Zone__Access;
current_location.update_lineno(14097);
/* DIAMETER_Types.ttcn, line 14097 */
const_c__AVP__Code__GI__3GPP__3GPP__Selection__Mode.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__Selection__Mode;
current_location.update_lineno(14099);
/* DIAMETER_Types.ttcn, line 14099 */
const_c__AVP__Code__DNAS__NONE__QoS__Filter__Rule.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__QoS__Filter__Rule;
current_location.update_lineno(14101);
/* DIAMETER_Types.ttcn, line 14101 */
const_c__AVP__Code__AAA__3GPP__Complete__Data__List__Included__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Complete__Data__List__Included__Indicator;
current_location.update_lineno(14103);
/* DIAMETER_Types.ttcn, line 14103 */
const_c__AVP__Code__MIPv4__NONE__MIP__MN__AAA__SPI.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__MN__AAA__SPI;
current_location.update_lineno(14105);
/* DIAMETER_Types.ttcn, line 14105 */
const_c__AVP__Code__DCA__3GPP__LCS__Client__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Client__Name;
current_location.update_lineno(14107);
/* DIAMETER_Types.ttcn, line 14107 */
const_c__AVP__Code__GI__3GPP__3GPP__SGSN__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__SGSN__Address;
current_location.update_lineno(14109);
/* DIAMETER_Types.ttcn, line 14109 */
const_c__AVP__Code__DCA__3GPP__Related__IMS__Charging__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Related__IMS__Charging__Identifier;
current_location.update_lineno(14111);
/* DIAMETER_Types.ttcn, line 14111 */
const_c__AVP__Code__DCA__3GPP__Called__Asserted__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Called__Asserted__Identity;
current_location.update_lineno(14113);
/* DIAMETER_Types.ttcn, line 14113 */
const_c__AVP__Code__DCA__3GPP__TWAG__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__TWAG__Address;
current_location.update_lineno(14115);
/* DIAMETER_Types.ttcn, line 14115 */
const_c__AVP__Code__MIPv4__NONE__MIP__MSA__Lifetime.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__MSA__Lifetime;
current_location.update_lineno(14117);
/* DIAMETER_Types.ttcn, line 14117 */
const_c__AVP__Code__DCA__3GPP__Talk__Burst__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Talk__Burst__Time;
current_location.update_lineno(14119);
/* DIAMETER_Types.ttcn, line 14119 */
const_c__AVP__Code__DCA__3GPP__Token__Text.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Token__Text;
current_location.update_lineno(14121);
/* DIAMETER_Types.ttcn, line 14121 */
const_c__AVP__Code__DCA__3GPP__Rate__Control__Time__Unit.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Rate__Control__Time__Unit;
current_location.update_lineno(14123);
/* DIAMETER_Types.ttcn, line 14123 */
const_c__AVP__Code__GI__3GPP__External__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__External__Identifier;
current_location.update_lineno(14125);
/* DIAMETER_Types.ttcn, line 14125 */
const_c__AVP__Code__DCA__3GPP__Reason__Header.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Reason__Header;
current_location.update_lineno(14127);
/* DIAMETER_Types.ttcn, line 14127 */
const_c__AVP__Code__AAA__3GPP__WLCP__Key.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__WLCP__Key;
current_location.update_lineno(14129);
/* DIAMETER_Types.ttcn, line 14129 */
const_c__AVP__Code__S6__3GPP__Reachability__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Reachability__Type;
current_location.update_lineno(14131);
/* DIAMETER_Types.ttcn, line 14131 */
const_c__AVP__Code__DCA__3GPP__SIP__Request__Timestamp.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SIP__Request__Timestamp;
current_location.update_lineno(14133);
/* DIAMETER_Types.ttcn, line 14133 */
const_c__AVP__Code__DNAS__NONE__Framed__Route.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__Route;
current_location.update_lineno(14135);
/* DIAMETER_Types.ttcn, line 14135 */
const_c__AVP__Code__DNAS__NONE__Tunnel__Private__Group__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunnel__Private__Group__Id;
current_location.update_lineno(14137);
/* DIAMETER_Types.ttcn, line 14137 */
const_c__AVP__Code__DCC__NONE__CC__Request__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Request__Type;
current_location.update_lineno(14139);
/* DIAMETER_Types.ttcn, line 14139 */
const_c__AVP__Code__DCA__3GPP__ProSe__Source__IP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Source__IP__Address;
current_location.update_lineno(14141);
/* DIAMETER_Types.ttcn, line 14141 */
const_c__AVP__Code__S6__3GPP__Type__Of__External__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Type__Of__External__Identifier;
current_location.update_lineno(14143);
/* DIAMETER_Types.ttcn, line 14143 */
const_c__AVP__Code__PCC__3GPP__Event__Report__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Event__Report__Indication;
current_location.update_lineno(14145);
/* DIAMETER_Types.ttcn, line 14145 */
const_c__AVP__Code__AAA__3GPP__MDT__Configuration.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MDT__Configuration;
current_location.update_lineno(14147);
/* DIAMETER_Types.ttcn, line 14147 */
const_c__AVP__Code__PCC__3GPP__Usage__Monitoring__Report.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Usage__Monitoring__Report;
current_location.update_lineno(14149);
/* DIAMETER_Types.ttcn, line 14149 */
const_c__AVP__Code__DCA__3GPP__Number__Of__Participants.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Number__Of__Participants;
current_location.update_lineno(14151);
/* DIAMETER_Types.ttcn, line 14151 */
const_c__AVP__Code__DCA__3GPP__MSC__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MSC__Address;
current_location.update_lineno(14153);
/* DIAMETER_Types.ttcn, line 14153 */
const_c__AVP__Code__CxDx__3GPP__Priviledged__Sender__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Priviledged__Sender__Indication;
current_location.update_lineno(14155);
/* DIAMETER_Types.ttcn, line 14155 */
const_c__AVP__Code__AAA__3GPP__Adjacent__Access__Restriction__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Adjacent__Access__Restriction__Data;
current_location.update_lineno(14157);
/* DIAMETER_Types.ttcn, line 14157 */
const_c__AVP__Code__DCA__3GPP__AoC__Service__Obligatory__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__AoC__Service__Obligatory__Type;
current_location.update_lineno(14159);
/* DIAMETER_Types.ttcn, line 14159 */
const_c__AVP__Code__AAA__3GPP__RAT__Frequency__Selection__Priority__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__RAT__Frequency__Selection__Priority__ID;
current_location.update_lineno(14161);
/* DIAMETER_Types.ttcn, line 14161 */
const_c__AVP__Code__DCA__3GPP__Time__First__Usage.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Time__First__Usage;
current_location.update_lineno(14163);
/* DIAMETER_Types.ttcn, line 14163 */
const_c__AVP__Code__CxDx__3GPP__Reason__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Reason__Info;
current_location.update_lineno(14165);
/* DIAMETER_Types.ttcn, line 14165 */
const_c__AVP__Code__PCC__3GPP__Default__EPS__Bearer__QoS.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Default__EPS__Bearer__QoS;
current_location.update_lineno(14167);
/* DIAMETER_Types.ttcn, line 14167 */
const_c__AVP__Code__AAA__3GPP__CLR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__CLR__Flags;
current_location.update_lineno(14169);
/* DIAMETER_Types.ttcn, line 14169 */
const_c__AVP__Code__AAA__3GPP__ULR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__ULR__Flags;
current_location.update_lineno(14171);
/* DIAMETER_Types.ttcn, line 14171 */
const_c__AVP__Code__DCA__3GPP__Originating__SCCP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Originating__SCCP__Address;
current_location.update_lineno(14173);
/* DIAMETER_Types.ttcn, line 14173 */
const_c__AVP__Code__AAA__3GPP__ICS__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__ICS__Indicator;
current_location.update_lineno(14175);
/* DIAMETER_Types.ttcn, line 14175 */
const_c__AVP__Code__DNAS__NONE__Calling__Station__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Calling__Station__Id;
current_location.update_lineno(14177);
/* DIAMETER_Types.ttcn, line 14177 */
const_c__AVP__Code__DNAS__NONE__Tunnel__Client__Auth__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunnel__Client__Auth__Id;
current_location.update_lineno(14179);
/* DIAMETER_Types.ttcn, line 14179 */
const_c__AVP__Code__DCC__NONE__Currency__Code.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Currency__Code;
current_location.update_lineno(14181);
/* DIAMETER_Types.ttcn, line 14181 */
const_c__AVP__Code__AAA__3GPP__Cancellation__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Cancellation__Type;
current_location.update_lineno(14183);
/* DIAMETER_Types.ttcn, line 14183 */
const_c__AVP__Code__BASE__NONE__E2E__Sequence.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__E2E__Sequence;
current_location.update_lineno(14185);
/* DIAMETER_Types.ttcn, line 14185 */
const_c__AVP__Code__BASE__NONE__Origin__Realm.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Origin__Realm;
current_location.update_lineno(14187);
/* DIAMETER_Types.ttcn, line 14187 */
const_c__AVP__Code__AAA__3GPP__PDN__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__PDN__Type;
current_location.update_lineno(14189);
/* DIAMETER_Types.ttcn, line 14189 */
const_c__AVP__Code__DCA__3GPP__Scale__Factor.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Scale__Factor;
current_location.update_lineno(14191);
/* DIAMETER_Types.ttcn, line 14191 */
const_c__AVP__Code__DCA__3GPP__IM__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__IM__Information;
current_location.update_lineno(14193);
/* DIAMETER_Types.ttcn, line 14193 */
const_c__AVP__Code__DNAS__NONE__Prompt.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Prompt;
current_location.update_lineno(14195);
/* DIAMETER_Types.ttcn, line 14195 */
const_c__AVP__Code__DCA__3GPP__SDP__Offer__Timestamp.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SDP__Offer__Timestamp;
current_location.update_lineno(14197);
/* DIAMETER_Types.ttcn, line 14197 */
const_c__AVP__Code__AAA__3GPP__PPR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__PPR__Flags;
current_location.update_lineno(14199);
/* DIAMETER_Types.ttcn, line 14199 */
const_c__AVP__Code__DCA__3GPP__MM__Content__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MM__Content__Type;
current_location.update_lineno(14201);
/* DIAMETER_Types.ttcn, line 14201 */
const_c__AVP__Code__DCA__3GPP__CPDT__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__CPDT__Information;
current_location.update_lineno(14203);
/* DIAMETER_Types.ttcn, line 14203 */
const_c__AVP__Code__GI__3GPP__3GPP__GGSN__IPv6__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__GGSN__IPv6__Address;
current_location.update_lineno(14205);
/* DIAMETER_Types.ttcn, line 14205 */
const_c__AVP__Code__AAA__3GPP__DER__S6b__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__DER__S6b__Flags;
current_location.update_lineno(14207);
/* DIAMETER_Types.ttcn, line 14207 */
const_c__AVP__Code__DCA__3GPP__SCS__Realm.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SCS__Realm;
current_location.update_lineno(14209);
/* DIAMETER_Types.ttcn, line 14209 */
const_c__AVP__Code__DCA__3GPP__LCS__Requestor__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Requestor__Id;
current_location.update_lineno(14211);
/* DIAMETER_Types.ttcn, line 14211 */
const_c__AVP__Code__RX__3GPP__Access__Network__Charging__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Access__Network__Charging__Identifier;
current_location.update_lineno(14213);
/* DIAMETER_Types.ttcn, line 14213 */
const_c__AVP__Code__DCC__NONE__Redirect__Server.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Redirect__Server;
current_location.update_lineno(14215);
/* DIAMETER_Types.ttcn, line 14215 */
const_c__AVP__Code__S6__3GPP__AESE__Communication__Pattern__Config__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__AESE__Communication__Pattern__Config__Status;
current_location.update_lineno(14217);
/* DIAMETER_Types.ttcn, line 14217 */
const_c__AVP__Code__DCA__3GPP__PoC__User__Role__info__Units.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__User__Role__info__Units;
current_location.update_lineno(14219);
/* DIAMETER_Types.ttcn, line 14219 */
const_c__AVP__Code__DCA__3GPP__Variable__Part.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Variable__Part;
current_location.update_lineno(14221);
/* DIAMETER_Types.ttcn, line 14221 */
const_c__AVP__Code__DCA__3GPP__ProSe__3rd__Party__Application__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__3rd__Party__Application__ID;
current_location.update_lineno(14223);
/* DIAMETER_Types.ttcn, line 14223 */
const_c__AVP__Code__S6__3GPP__Enhanced__Coverage__Restriction__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Enhanced__Coverage__Restriction__Data;
current_location.update_lineno(14225);
/* DIAMETER_Types.ttcn, line 14225 */
const_c__AVP__Code__PCC__3GPP__Bearer__Operation.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Bearer__Operation;
current_location.update_lineno(14227);
/* DIAMETER_Types.ttcn, line 14227 */
const_c__AVP__Code__AAA__3GPP__Current__Location__Retrieved.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Current__Location__Retrieved;
current_location.update_lineno(14229);
/* DIAMETER_Types.ttcn, line 14229 */
const_c__AVP__Code__RX__3GPP__Pre__emption__Control__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Pre__emption__Control__Info;
current_location.update_lineno(14231);
/* DIAMETER_Types.ttcn, line 14231 */
const_c__AVP__Code__PCC__3GPP__TDF__Application__Instance__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__TDF__Application__Instance__Identifier;
current_location.update_lineno(14233);
/* DIAMETER_Types.ttcn, line 14233 */
const_c__AVP__Code__DCA__3GPP__SM__Device__Trigger__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SM__Device__Trigger__Information;
current_location.update_lineno(14235);
/* DIAMETER_Types.ttcn, line 14235 */
const_c__AVP__Code__DCA__3GPP__Service__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Service__Information;
current_location.update_lineno(14237);
/* DIAMETER_Types.ttcn, line 14237 */
const_c__AVP__Code__BASE__NONE__Acct__Interim__Interval.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Acct__Interim__Interval;
current_location.update_lineno(14239);
/* DIAMETER_Types.ttcn, line 14239 */
const_c__AVP__Code__RX__3GPP__Media__Component__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Media__Component__Number;
current_location.update_lineno(14241);
/* DIAMETER_Types.ttcn, line 14241 */
const_c__AVP__Code__CxDx__3GPP__Path.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Path;
current_location.update_lineno(14243);
/* DIAMETER_Types.ttcn, line 14243 */
const_c__AVP__Code__PCC__3GPP__Packet__Filter__Usage.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Packet__Filter__Usage;
current_location.update_lineno(14245);
/* DIAMETER_Types.ttcn, line 14245 */
const_c__AVP__Code__AAA__3GPP__Event__Threshold__Event__1F.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Event__Threshold__Event__1F;
current_location.update_lineno(14247);
/* DIAMETER_Types.ttcn, line 14247 */
const_c__AVP__Code__S6__3GPP__MONTE__Location__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__MONTE__Location__Type;
current_location.update_lineno(14249);
/* DIAMETER_Types.ttcn, line 14249 */
const_c__AVP__Code__DCA__3GPP__Inter__Operator__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Inter__Operator__Identifier;
current_location.update_lineno(14251);
/* DIAMETER_Types.ttcn, line 14251 */
const_c__AVP__Code__AAA__3GPP__RDS__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__RDS__Indicator;
current_location.update_lineno(14253);
/* DIAMETER_Types.ttcn, line 14253 */
const_c__AVP__Code__DCA__3GPP__Proximity__Cancellation__Timestamp.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Proximity__Cancellation__Timestamp;
current_location.update_lineno(14255);
/* DIAMETER_Types.ttcn, line 14255 */
const_c__AVP__Code__DCA__3GPP__MMTel__SService__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MMTel__SService__Type;
current_location.update_lineno(14257);
/* DIAMETER_Types.ttcn, line 14257 */
const_c__AVP__Code__CxDx__3GPP__Optional__Capability.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Optional__Capability;
current_location.update_lineno(14259);
/* DIAMETER_Types.ttcn, line 14259 */
const_c__AVP__Code__PCC__3GPP__Tunnel__Header__Length.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Tunnel__Header__Length;
current_location.update_lineno(14261);
/* DIAMETER_Types.ttcn, line 14261 */
const_c__AVP__Code__AAA__3GPP__Reporting__Trigger.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Reporting__Trigger;
current_location.update_lineno(14263);
/* DIAMETER_Types.ttcn, line 14263 */
const_c__AVP__Code__PCC__3GPP__Conditional__APN__Aggregate__Max__Bitrate.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Conditional__APN__Aggregate__Max__Bitrate;
current_location.update_lineno(14265);
/* DIAMETER_Types.ttcn, line 14265 */
const_c__AVP__Code__CxDx__3GPP__Secondary__Event__Charging__Function__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Secondary__Event__Charging__Function__Name;
current_location.update_lineno(14267);
/* DIAMETER_Types.ttcn, line 14267 */
const_c__AVP__Code__AAA__3GPP__Group__PLMN__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Group__PLMN__Id;
current_location.update_lineno(14269);
/* DIAMETER_Types.ttcn, line 14269 */
const_c__AVP__Code__DCA__3GPP__Reply__Path__Requested.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Reply__Path__Requested;
current_location.update_lineno(14271);
/* DIAMETER_Types.ttcn, line 14271 */
const_c__AVP__Code__AAA__3GPP__User__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__User__Id;
current_location.update_lineno(14273);
/* DIAMETER_Types.ttcn, line 14273 */
const_c__AVP__Code__DCA__3GPP__Serving__Node__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Serving__Node__Type;
current_location.update_lineno(14275);
/* DIAMETER_Types.ttcn, line 14275 */
const_c__AVP__Code__DNAS__NONE__Login__LAT__Node.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Login__LAT__Node;
current_location.update_lineno(14277);
/* DIAMETER_Types.ttcn, line 14277 */
const_c__AVP__Code__DNAS__NONE__Originating__Line__Info.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Originating__Line__Info;
current_location.update_lineno(14279);
/* DIAMETER_Types.ttcn, line 14279 */
const_c__AVP__Code__DCC__NONE__Exponent.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Exponent;
current_location.update_lineno(14281);
/* DIAMETER_Types.ttcn, line 14281 */
const_c__AVP__Code__MIPv6__NONE__MIP__Authenticator.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__MIP__Authenticator;
current_location.update_lineno(14283);
/* DIAMETER_Types.ttcn, line 14283 */
const_c__AVP__Code__AAA__3GPP__Requested__UTRAN__GERAN__Authentication__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Requested__UTRAN__GERAN__Authentication__Info;
current_location.update_lineno(14285);
/* DIAMETER_Types.ttcn, line 14285 */
const_c__AVP__Code__MIPv4__NONE__Accounting__Input__Octets.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__Accounting__Input__Octets;
current_location.update_lineno(14287);
/* DIAMETER_Types.ttcn, line 14287 */
const_c__AVP__Code__AAA__3GPP__EPS__User__State.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__EPS__User__State;
current_location.update_lineno(14289);
/* DIAMETER_Types.ttcn, line 14289 */
const_c__AVP__Code__BASE__NONE__Origin__Host.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Origin__Host;
current_location.update_lineno(14291);
/* DIAMETER_Types.ttcn, line 14291 */
const_c__AVP__Code__AAA__3GPP__Access__Authorization__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Access__Authorization__Flags;
current_location.update_lineno(14293);
/* DIAMETER_Types.ttcn, line 14293 */
const_c__AVP__Code__DCA__3GPP__PDP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PDP__Address;
current_location.update_lineno(14295);
/* DIAMETER_Types.ttcn, line 14295 */
const_c__AVP__Code__DCA__3GPP__CP__CIoT__EPS__Optimisation__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__CP__CIoT__EPS__Optimisation__Indicator;
current_location.update_lineno(14297);
/* DIAMETER_Types.ttcn, line 14297 */
const_c__AVP__Code__DCA__3GPP__NNI__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__NNI__Information;
current_location.update_lineno(14299);
/* DIAMETER_Types.ttcn, line 14299 */
const_c__AVP__Code__DCA__3GPP__Location__Estimate.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Location__Estimate;
current_location.update_lineno(14301);
/* DIAMETER_Types.ttcn, line 14301 */
const_c__AVP__Code__DCA__3GPP__Offline__Charging.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Offline__Charging;
current_location.update_lineno(14303);
/* DIAMETER_Types.ttcn, line 14303 */
const_c__AVP__Code__RX__3GPP__Retry__Interval.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Retry__Interval;
current_location.update_lineno(14305);
/* DIAMETER_Types.ttcn, line 14305 */
const_c__AVP__Code__BASE__NONE__Accounting__Session__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Accounting__Session__Id;
current_location.update_lineno(14307);
/* DIAMETER_Types.ttcn, line 14307 */
const_c__AVP__Code__DCA__3GPP__Additional__Content__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Additional__Content__Information;
current_location.update_lineno(14309);
/* DIAMETER_Types.ttcn, line 14309 */
const_c__AVP__Code__DCC__NONE__Restriction__Filter__Rule.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Restriction__Filter__Rule;
current_location.update_lineno(14311);
/* DIAMETER_Types.ttcn, line 14311 */
const_c__AVP__Code__DCA__3GPP__Cause__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Cause__Code;
current_location.update_lineno(14313);
/* DIAMETER_Types.ttcn, line 14313 */
const_c__AVP__Code__AAA__3GPP__TWAN__Connection__Mode.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__TWAN__Connection__Mode;
current_location.update_lineno(14315);
/* DIAMETER_Types.ttcn, line 14315 */
const_c__AVP__Code__PCC__3GPP__Packet__Filter__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Packet__Filter__Identifier;
current_location.update_lineno(14317);
/* DIAMETER_Types.ttcn, line 14317 */
const_c__AVP__Code__DCA__3GPP__Address__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Address__Data;
current_location.update_lineno(14319);
/* DIAMETER_Types.ttcn, line 14319 */
const_c__AVP__Code__S6__3GPP__SCEF__Reference__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__SCEF__Reference__ID;
current_location.update_lineno(14321);
/* DIAMETER_Types.ttcn, line 14321 */
const_c__AVP__Code__DCA__3GPP__Content__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Content__Type;
current_location.update_lineno(14323);
/* DIAMETER_Types.ttcn, line 14323 */
const_c__AVP__Code__PCC__3GPP__Resource__Release__Notification.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Resource__Release__Notification;
current_location.update_lineno(14325);
/* DIAMETER_Types.ttcn, line 14325 */
const_c__AVP__Code__PCC__3GPP__ADC__Rule__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__ADC__Rule__Name;
current_location.update_lineno(14327);
/* DIAMETER_Types.ttcn, line 14327 */
const_c__AVP__Code__DCA__3GPP__ProSe__Function__IP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Function__IP__Address;
current_location.update_lineno(14329);
/* DIAMETER_Types.ttcn, line 14329 */
const_c__AVP__Code__PCC__3GPP__Guaranteed__Bitrate__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Guaranteed__Bitrate__DL;
current_location.update_lineno(14331);
/* DIAMETER_Types.ttcn, line 14331 */
const_c__AVP__Code__BASE__NONE__Disconnect__Cause.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Disconnect__Cause;
current_location.update_lineno(14333);
/* DIAMETER_Types.ttcn, line 14333 */
const_c__AVP__Code__AAA__3GPP__Error__Diagnostic.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Error__Diagnostic;
current_location.update_lineno(14335);
/* DIAMETER_Types.ttcn, line 14335 */
const_c__AVP__Code__RX__3GPP__Extended__Max__Supported__BW__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Extended__Max__Supported__BW__UL;
current_location.update_lineno(14337);
/* DIAMETER_Types.ttcn, line 14337 */
const_c__AVP__Code__PCC__3GPP__UDP__Source__Port.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__UDP__Source__Port;
current_location.update_lineno(14339);
/* DIAMETER_Types.ttcn, line 14339 */
const_c__AVP__Code__DCC__NONE__CC__Total__Octets.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Total__Octets;
current_location.update_lineno(14341);
/* DIAMETER_Types.ttcn, line 14341 */
const_c__AVP__Code__BASE__NONE__Accounting__Record__Type.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Accounting__Record__Type;
current_location.update_lineno(14343);
/* DIAMETER_Types.ttcn, line 14343 */
const_c__AVP__Code__DCA__3GPP__SMS__Result.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SMS__Result;
current_location.update_lineno(14345);
/* DIAMETER_Types.ttcn, line 14345 */
const_c__AVP__Code__DCA__3GPP__MMS__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MMS__Information;
current_location.update_lineno(14347);
/* DIAMETER_Types.ttcn, line 14347 */
const_c__AVP__Code__CxDx__3GPP__From__SIP__Header.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__From__SIP__Header;
current_location.update_lineno(14349);
/* DIAMETER_Types.ttcn, line 14349 */
const_c__AVP__Code__PCC__3GPP__Routing__Rule__Definition.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Routing__Rule__Definition;
current_location.update_lineno(14351);
/* DIAMETER_Types.ttcn, line 14351 */
const_c__AVP__Code__AAA__3GPP__SIPTO__Local__Network__Permission.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SIPTO__Local__Network__Permission;
current_location.update_lineno(14353);
/* DIAMETER_Types.ttcn, line 14353 */
const_c__AVP__Code__DCA__3GPP__CUG__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__CUG__Information;
current_location.update_lineno(14355);
/* DIAMETER_Types.ttcn, line 14355 */
const_c__AVP__Code__AAA__3GPP__VPLMN__Dynamic__Address__Allowed.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__VPLMN__Dynamic__Address__Allowed;
current_location.update_lineno(14357);
/* DIAMETER_Types.ttcn, line 14357 */
const_c__AVP__Code__DCC__NONE__Value__Digits.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Value__Digits;
current_location.update_lineno(14359);
/* DIAMETER_Types.ttcn, line 14359 */
const_c__AVP__Code__MIPv4__NONE__MIP__MN__AAA__Auth.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__MN__AAA__Auth;
current_location.update_lineno(14361);
/* DIAMETER_Types.ttcn, line 14361 */
const_c__AVP__Code__BASE__NONE__Acct__Application__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Acct__Application__Id;
current_location.update_lineno(14363);
/* DIAMETER_Types.ttcn, line 14363 */
const_c__AVP__Code__DCA__3GPP__Associated__Party__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Associated__Party__Address;
current_location.update_lineno(14365);
/* DIAMETER_Types.ttcn, line 14365 */
const_c__AVP__Code__CxDx__3GPP__SIP__Authenticate.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__SIP__Authenticate;
current_location.update_lineno(14367);
/* DIAMETER_Types.ttcn, line 14367 */
const_c__AVP__Code__AAA__3GPP__Service__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Service__Type;
current_location.update_lineno(14369);
/* DIAMETER_Types.ttcn, line 14369 */
const_c__AVP__Code__AAA__3GPP__Immediate__Response__Preferred.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Immediate__Response__Preferred;
current_location.update_lineno(14371);
/* DIAMETER_Types.ttcn, line 14371 */
const_c__AVP__Code__DNAS__NONE__Framed__Appletalk__Zone.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__Appletalk__Zone;
current_location.update_lineno(14373);
/* DIAMETER_Types.ttcn, line 14373 */
const_c__AVP__Code__DNAS__NONE__Login__IPv6__Host.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Login__IPv6__Host;
current_location.update_lineno(14375);
/* DIAMETER_Types.ttcn, line 14375 */
const_c__AVP__Code__DCA__3GPP__Local__GW__Inserted__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Local__GW__Inserted__Indication;
current_location.update_lineno(14377);
/* DIAMETER_Types.ttcn, line 14377 */
const_c__AVP__Code__AAA__3GPP__XRES.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__XRES;
current_location.update_lineno(14379);
/* DIAMETER_Types.ttcn, line 14379 */
const_c__AVP__Code__DCC__NONE__Final__Unit__Indication.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Final__Unit__Indication;
current_location.update_lineno(14381);
/* DIAMETER_Types.ttcn, line 14381 */
const_c__AVP__Code__DCA__3GPP__Deferred__Location__Event__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Deferred__Location__Event__Type;
current_location.update_lineno(14383);
/* DIAMETER_Types.ttcn, line 14383 */
const_c__AVP__Code__GI__3GPP__3GPP__IMSI.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__IMSI;
current_location.update_lineno(14385);
/* DIAMETER_Types.ttcn, line 14385 */
const_c__AVP__Code__AAA__3GPP__User__State.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__User__State;
current_location.update_lineno(14387);
/* DIAMETER_Types.ttcn, line 14387 */
const_c__AVP__Code__MIPv4__NONE__MIP__MN__to__HA__MSA.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__MN__to__HA__MSA;
current_location.update_lineno(14389);
/* DIAMETER_Types.ttcn, line 14389 */
const_c__AVP__Code__BASE__NONE__Result__Code.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Result__Code;
current_location.update_lineno(14391);
/* DIAMETER_Types.ttcn, line 14391 */
const_c__AVP__Code__DCA__3GPP__Envelope.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Envelope;
current_location.update_lineno(14393);
/* DIAMETER_Types.ttcn, line 14393 */
const_c__AVP__Code__DCA__3GPP__Monitoring__Event__Configuration__Activity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Monitoring__Event__Configuration__Activity;
current_location.update_lineno(14395);
/* DIAMETER_Types.ttcn, line 14395 */
const_c__AVP__Code__DCA__3GPP__IMS__Communication__Service__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__IMS__Communication__Service__Identifier;
current_location.update_lineno(14397);
/* DIAMETER_Types.ttcn, line 14397 */
const_c__AVP__Code__DNAS__NONE__Framed__IP__Address.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__IP__Address;
current_location.update_lineno(14399);
/* DIAMETER_Types.ttcn, line 14399 */
const_c__AVP__Code__AAA__3GPP__Trust__Relationship__Update.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Trust__Relationship__Update;
current_location.update_lineno(14401);
/* DIAMETER_Types.ttcn, line 14401 */
const_c__AVP__Code__DCA__3GPP__APN__Rate__Control__Downlink.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__APN__Rate__Control__Downlink;
current_location.update_lineno(14403);
/* DIAMETER_Types.ttcn, line 14403 */
const_c__AVP__Code__DCA__3GPP__Session__Direction.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Session__Direction;
current_location.update_lineno(14405);
/* DIAMETER_Types.ttcn, line 14405 */
const_c__AVP__Code__S6__3GPP__IP__SM__GW__Realm.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__IP__SM__GW__Realm;
current_location.update_lineno(14407);
/* DIAMETER_Types.ttcn, line 14407 */
const_c__AVP__Code__DCA__3GPP__Monitoring__UE__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Monitoring__UE__Identifier;
current_location.update_lineno(14409);
/* DIAMETER_Types.ttcn, line 14409 */
const_c__AVP__Code__S6__3GPP__Reference__ID__Validity__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Reference__ID__Validity__Time;
current_location.update_lineno(14411);
/* DIAMETER_Types.ttcn, line 14411 */
const_c__AVP__Code__PCC__3GPP__TFT__Packet__Filter__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__TFT__Packet__Filter__Information;
current_location.update_lineno(14413);
/* DIAMETER_Types.ttcn, line 14413 */
const_c__AVP__Code__AAA__3GPP__E__UTRAN__Cell__Global__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__E__UTRAN__Cell__Global__Identity;
current_location.update_lineno(14415);
/* DIAMETER_Types.ttcn, line 14415 */
const_c__AVP__Code__RX__3GPP__Min__Desired__Bandwidth__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Min__Desired__Bandwidth__DL;
current_location.update_lineno(14417);
/* DIAMETER_Types.ttcn, line 14417 */
const_c__AVP__Code__DCA__3GPP__Transmitter__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Transmitter__Info;
current_location.update_lineno(14419);
/* DIAMETER_Types.ttcn, line 14419 */
const_c__AVP__Code__S6__3GPP__Group__Reporting__Guard__Timer.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Group__Reporting__Guard__Timer;
current_location.update_lineno(14421);
/* DIAMETER_Types.ttcn, line 14421 */
const_c__AVP__Code__DCA__3GPP__PS__Furnish__Charging__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PS__Furnish__Charging__Information;
current_location.update_lineno(14423);
/* DIAMETER_Types.ttcn, line 14423 */
const_c__AVP__Code__CxDx__3GPP__Associated__Identities.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Associated__Identities;
current_location.update_lineno(14425);
/* DIAMETER_Types.ttcn, line 14425 */
const_c__AVP__Code__PCC__3GPP__Session__Linking__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Session__Linking__Indicator;
current_location.update_lineno(14427);
/* DIAMETER_Types.ttcn, line 14427 */
const_c__AVP__Code__BASE__NONE__Auth__Session__State.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Auth__Session__State;
current_location.update_lineno(14429);
/* DIAMETER_Types.ttcn, line 14429 */
const_c__AVP__Code__S6__3GPP__Maximum__Number__of__Reports.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Maximum__Number__of__Reports;
current_location.update_lineno(14431);
/* DIAMETER_Types.ttcn, line 14431 */
const_c__AVP__Code__PCC__3GPP__PRA__Install.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__PRA__Install;
current_location.update_lineno(14433);
/* DIAMETER_Types.ttcn, line 14433 */
const_c__AVP__Code__AAA__3GPP__V2X__Permission.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__V2X__Permission;
current_location.update_lineno(14435);
/* DIAMETER_Types.ttcn, line 14435 */
const_c__AVP__Code__DCA__3GPP__ProSe__Range__Class.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Range__Class;
current_location.update_lineno(14437);
/* DIAMETER_Types.ttcn, line 14437 */
const_c__AVP__Code__DCA__3GPP__Carrier__Select__Routing__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Carrier__Select__Routing__Information;
current_location.update_lineno(14439);
/* DIAMETER_Types.ttcn, line 14439 */
const_c__AVP__Code__PCC__3GPP__QoS__Negotiation.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__QoS__Negotiation;
current_location.update_lineno(14441);
/* DIAMETER_Types.ttcn, line 14441 */
const_c__AVP__Code__AAA__3GPP__LIPA__Permission.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__LIPA__Permission;
current_location.update_lineno(14443);
/* DIAMETER_Types.ttcn, line 14443 */
const_c__AVP__Code__CxDx__3GPP__SIP__Auth__Data__Item.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__SIP__Auth__Data__Item;
current_location.update_lineno(14445);
/* DIAMETER_Types.ttcn, line 14445 */
const_c__AVP__Code__AAA__3GPP__3GPP2__MEID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__3GPP2__MEID;
current_location.update_lineno(14447);
/* DIAMETER_Types.ttcn, line 14447 */
const_c__AVP__Code__MIPv4__NONE__MIP__FA__to__MN__MSA.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__FA__to__MN__MSA;
current_location.update_lineno(14449);
/* DIAMETER_Types.ttcn, line 14449 */
const_c__AVP__Code__AAA__3GPP__Subscription__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Subscription__Data;
current_location.update_lineno(14451);
/* DIAMETER_Types.ttcn, line 14451 */
const_c__AVP__Code__CxDx__3GPP__Multiple__Registration__Indication.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Multiple__Registration__Indication;
current_location.update_lineno(14453);
/* DIAMETER_Types.ttcn, line 14453 */
const_c__AVP__Code__AAA__3GPP__WLAN__offloadability__UTRAN.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__WLAN__offloadability__UTRAN;
current_location.update_lineno(14455);
/* DIAMETER_Types.ttcn, line 14455 */
const_c__AVP__Code__BASE__NONE__Vendor__Specific__Application__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Vendor__Specific__Application__Id;
current_location.update_lineno(14457);
/* DIAMETER_Types.ttcn, line 14457 */
const_c__AVP__Code__DCA__3GPP__IMSI__Unauthenticated__Flag.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__IMSI__Unauthenticated__Flag;
current_location.update_lineno(14459);
/* DIAMETER_Types.ttcn, line 14459 */
const_c__AVP__Code__DCA__3GPP__Interface__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Interface__Id;
current_location.update_lineno(14461);
/* DIAMETER_Types.ttcn, line 14461 */
const_c__AVP__Code__AAA__3GPP__CSG__Subscription__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__CSG__Subscription__Data;
current_location.update_lineno(14463);
/* DIAMETER_Types.ttcn, line 14463 */
const_c__AVP__Code__DCA__3GPP__Diagnostics.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Diagnostics;
current_location.update_lineno(14465);
/* DIAMETER_Types.ttcn, line 14465 */
const_c__AVP__Code__MIPv6__NONE__Service__Selection.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__Service__Selection;
current_location.update_lineno(14467);
/* DIAMETER_Types.ttcn, line 14467 */
const_c__AVP__Code__AAA__3GPP__TS__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__TS__Code;
current_location.update_lineno(14469);
/* DIAMETER_Types.ttcn, line 14469 */
const_c__AVP__Code__DNAS__NONE__Tunnel__Client__Endpoint.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Tunnel__Client__Endpoint;
current_location.update_lineno(14471);
/* DIAMETER_Types.ttcn, line 14471 */
const_c__AVP__Code__AAA__3GPP__AN__Trusted.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__AN__Trusted;
current_location.update_lineno(14473);
/* DIAMETER_Types.ttcn, line 14473 */
const_c__AVP__Code__DCA__3GPP__Monitoring__Event__Funtionality.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Monitoring__Event__Funtionality;
current_location.update_lineno(14475);
/* DIAMETER_Types.ttcn, line 14475 */
const_c__AVP__Code__DCA__3GPP__Aux__Applic__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Aux__Applic__Info;
current_location.update_lineno(14477);
/* DIAMETER_Types.ttcn, line 14477 */
const_c__AVP__Code__MIPv4__NONE__MIP__Nonce.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Nonce;
current_location.update_lineno(14479);
/* DIAMETER_Types.ttcn, line 14479 */
const_c__AVP__Code__S6__3GPP__IP__SM__GW__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__IP__SM__GW__Number;
current_location.update_lineno(14481);
/* DIAMETER_Types.ttcn, line 14481 */
const_c__AVP__Code__AAA__3GPP__AAR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__AAR__Flags;
current_location.update_lineno(14483);
/* DIAMETER_Types.ttcn, line 14483 */
const_c__AVP__Code__DCA__3GPP__LCS__Client__External__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Client__External__ID;
current_location.update_lineno(14485);
/* DIAMETER_Types.ttcn, line 14485 */
const_c__AVP__Code__DCA__3GPP__VLR__Number.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__VLR__Number;
current_location.update_lineno(14487);
/* DIAMETER_Types.ttcn, line 14487 */
const_c__AVP__Code__PCC__3GPP__Charging__Rule__Install.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Charging__Rule__Install;
current_location.update_lineno(14489);
/* DIAMETER_Types.ttcn, line 14489 */
const_c__AVP__Code__RX__3GPP__Rx__Request__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Rx__Request__Type;
current_location.update_lineno(14491);
/* DIAMETER_Types.ttcn, line 14491 */
const_c__AVP__Code__S6__3GPP__NIDD__Authorization__Response.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__NIDD__Authorization__Response;
current_location.update_lineno(14493);
/* DIAMETER_Types.ttcn, line 14493 */
const_c__AVP__Code__DCA__3GPP__Outgoing__Trunk__Group__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Outgoing__Trunk__Group__Id;
current_location.update_lineno(14495);
/* DIAMETER_Types.ttcn, line 14495 */
const_c__AVP__Code__AAA__3GPP__Transport__Access__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Transport__Access__Type;
current_location.update_lineno(14497);
/* DIAMETER_Types.ttcn, line 14497 */
const_c__AVP__Code__DCC__NONE__Subscription__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Subscription__Id;
current_location.update_lineno(14499);
/* DIAMETER_Types.ttcn, line 14499 */
const_c__AVP__Code__PCC__3GPP__QoS__Rule__Remove.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__QoS__Rule__Remove;
current_location.update_lineno(14501);
/* DIAMETER_Types.ttcn, line 14501 */
const_c__AVP__Code__AAA__3GPP__VPLMN__CSG__Subscription__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__VPLMN__CSG__Subscription__Data;
current_location.update_lineno(14503);
/* DIAMETER_Types.ttcn, line 14503 */
const_c__AVP__Code__DCA__3GPP__Message__Body.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Message__Body;
current_location.update_lineno(14505);
/* DIAMETER_Types.ttcn, line 14505 */
const_c__AVP__Code__S6__3GPP__Communication__Duration__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Communication__Duration__Time;
current_location.update_lineno(14507);
/* DIAMETER_Types.ttcn, line 14507 */
const_c__AVP__Code__PCC__3GPP__Access__Availability__Change__Reason.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Access__Availability__Change__Reason;
current_location.update_lineno(14509);
/* DIAMETER_Types.ttcn, line 14509 */
const_c__AVP__Code__PCC__3GPP__TDF__Application__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__TDF__Application__Identifier;
current_location.update_lineno(14511);
/* DIAMETER_Types.ttcn, line 14511 */
const_c__AVP__Code__DCA__3GPP__Requested__PLMN__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Requested__PLMN__Identifier;
current_location.update_lineno(14513);
/* DIAMETER_Types.ttcn, line 14513 */
const_c__AVP__Code__AAA__3GPP__Location__Area__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Location__Area__Identity;
current_location.update_lineno(14515);
/* DIAMETER_Types.ttcn, line 14515 */
const_c__AVP__Code__RX__3GPP__Media__Component__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Media__Component__Status;
current_location.update_lineno(14517);
/* DIAMETER_Types.ttcn, line 14517 */
const_c__AVP__Code__AAA__3GPP__eDRX__Cycle__Length__Value.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__eDRX__Cycle__Length__Value;
current_location.update_lineno(14519);
/* DIAMETER_Types.ttcn, line 14519 */
const_c__AVP__Code__MIPv4__NONE__MIP__FA__Challenge.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__FA__Challenge;
current_location.update_lineno(14521);
/* DIAMETER_Types.ttcn, line 14521 */
const_c__AVP__Code__CxDx__3GPP__Visited__Network__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Visited__Network__Identifier;
current_location.update_lineno(14523);
/* DIAMETER_Types.ttcn, line 14523 */
const_c__AVP__Code__S6__3GPP__RIR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__RIR__Flags;
current_location.update_lineno(14525);
/* DIAMETER_Types.ttcn, line 14525 */
const_c__AVP__Code__DCA__3GPP__Volume__Quota__Threshold.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Volume__Quota__Threshold;
current_location.update_lineno(14527);
/* DIAMETER_Types.ttcn, line 14527 */
const_c__AVP__Code__DCA__3GPP__Incremental__Cost.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Incremental__Cost;
current_location.update_lineno(14529);
/* DIAMETER_Types.ttcn, line 14529 */
const_c__AVP__Code__PCC__3GPP__Usage__Monitoring__Level.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Usage__Monitoring__Level;
current_location.update_lineno(14531);
/* DIAMETER_Types.ttcn, line 14531 */
const_c__AVP__Code__AAA__3GPP__Collection__Period__RRM__LTE.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Collection__Period__RRM__LTE;
current_location.update_lineno(14533);
/* DIAMETER_Types.ttcn, line 14533 */
const_c__AVP__Code__PCC__3GPP__Extended__APN__AMBR__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Extended__APN__AMBR__UL;
current_location.update_lineno(14535);
/* DIAMETER_Types.ttcn, line 14535 */
const_c__AVP__Code__AAA__3GPP__Subscriber__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Subscriber__Status;
current_location.update_lineno(14537);
/* DIAMETER_Types.ttcn, line 14537 */
const_c__AVP__Code__CxDx__3GPP__Identity__with__Emergency__Registration.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Identity__with__Emergency__Registration;
current_location.update_lineno(14539);
/* DIAMETER_Types.ttcn, line 14539 */
const_c__AVP__Code__DCA__3GPP__Originator__Received__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Originator__Received__Address;
current_location.update_lineno(14541);
/* DIAMETER_Types.ttcn, line 14541 */
const_c__AVP__Code__DCA__3GPP__AoC__Service.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__AoC__Service;
current_location.update_lineno(14543);
/* DIAMETER_Types.ttcn, line 14543 */
const_c__AVP__Code__DCC__NONE__Tariff__Change__Usage.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Tariff__Change__Usage;
current_location.update_lineno(14545);
/* DIAMETER_Types.ttcn, line 14545 */
const_c__AVP__Code__AAA__3GPP__LCS__PrivacyException.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__LCS__PrivacyException;
current_location.update_lineno(14547);
/* DIAMETER_Types.ttcn, line 14547 */
const_c__AVP__Code__AAA__3GPP__QoS__Subscribed.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__QoS__Subscribed;
current_location.update_lineno(14549);
/* DIAMETER_Types.ttcn, line 14549 */
const_c__AVP__Code__DNAS__NONE__NAS__IP__Address.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__NAS__IP__Address;
current_location.update_lineno(14551);
/* DIAMETER_Types.ttcn, line 14551 */
const_c__AVP__Code__DCA__3GPP__Variable__Part__Value.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Variable__Part__Value;
current_location.update_lineno(14553);
/* DIAMETER_Types.ttcn, line 14553 */
const_c__AVP__Code__DCA__3GPP__Read__Reply__Report__Requested.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Read__Reply__Report__Requested;
current_location.update_lineno(14555);
/* DIAMETER_Types.ttcn, line 14555 */
const_c__AVP__Code__DCA__3GPP__Event__Charging__TimeStamp.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Event__Charging__TimeStamp;
current_location.update_lineno(14557);
/* DIAMETER_Types.ttcn, line 14557 */
const_c__AVP__Code__RX__3GPP__RR__Bandwidth.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__RR__Bandwidth;
current_location.update_lineno(14559);
/* DIAMETER_Types.ttcn, line 14559 */
const_c__AVP__Code__DNAS__NONE__CHAP__Auth.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__CHAP__Auth;
current_location.update_lineno(14561);
/* DIAMETER_Types.ttcn, line 14561 */
const_c__AVP__Code__DCC__NONE__Service__Context__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Service__Context__Id;
current_location.update_lineno(14563);
/* DIAMETER_Types.ttcn, line 14563 */
const_c__AVP__Code__MIPv4__NONE__MIP__Authenticator__Length.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Authenticator__Length;
current_location.update_lineno(14565);
/* DIAMETER_Types.ttcn, line 14565 */
const_c__AVP__Code__DCA__3GPP__SDP__TimeStamps.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SDP__TimeStamps;
current_location.update_lineno(14567);
/* DIAMETER_Types.ttcn, line 14567 */
const_c__AVP__Code__DCA__3GPP__IMS__Charging__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__IMS__Charging__Identifier;
current_location.update_lineno(14569);
/* DIAMETER_Types.ttcn, line 14569 */
const_c__AVP__Code__AAA__3GPP__MIP__FA__RK__SPI.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MIP__FA__RK__SPI;
current_location.update_lineno(14571);
/* DIAMETER_Types.ttcn, line 14571 */
const_c__AVP__Code__DCA__3GPP__Related__Trigger.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Related__Trigger;
current_location.update_lineno(14573);
/* DIAMETER_Types.ttcn, line 14573 */
const_c__AVP__Code__PCC__3GPP__APN__Aggregate__Max__Bitrate__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__APN__Aggregate__Max__Bitrate__DL;
current_location.update_lineno(14575);
/* DIAMETER_Types.ttcn, line 14575 */
const_c__AVP__Code__S6__3GPP__SCS__Identity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__SCS__Identity;
current_location.update_lineno(14577);
/* DIAMETER_Types.ttcn, line 14577 */
const_c__AVP__Code__DCA__3GPP__LCS__Name__String.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__LCS__Name__String;
current_location.update_lineno(14579);
/* DIAMETER_Types.ttcn, line 14579 */
const_c__AVP__Code__RX__3GPP__Access__Network__Charging__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Access__Network__Charging__Address;
current_location.update_lineno(14581);
/* DIAMETER_Types.ttcn, line 14581 */
const_c__AVP__Code__PCC__3GPP__Presence__Reporting__Area__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Presence__Reporting__Area__Identifier;
current_location.update_lineno(14583);
/* DIAMETER_Types.ttcn, line 14583 */
const_c__AVP__Code__BASE__NONE__Inband__Security__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Inband__Security__Id;
current_location.update_lineno(14585);
/* DIAMETER_Types.ttcn, line 14585 */
const_c__AVP__Code__DCA__3GPP__ISUP__Cause__Value.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ISUP__Cause__Value;
current_location.update_lineno(14587);
/* DIAMETER_Types.ttcn, line 14587 */
const_c__AVP__Code__PCC__3GPP__Charging__Rule__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Charging__Rule__Name;
current_location.update_lineno(14589);
/* DIAMETER_Types.ttcn, line 14589 */
const_c__AVP__Code__RX__3GPP__Ip__Domain__Id.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Ip__Domain__Id;
current_location.update_lineno(14591);
/* DIAMETER_Types.ttcn, line 14591 */
const_c__AVP__Code__PCC__3GPP__TDF__IP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__TDF__IP__Address;
current_location.update_lineno(14593);
/* DIAMETER_Types.ttcn, line 14593 */
const_c__AVP__Code__AAA__3GPP__UE__Usage__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__UE__Usage__Type;
current_location.update_lineno(14595);
/* DIAMETER_Types.ttcn, line 14595 */
const_c__AVP__Code__S6__3GPP__Enhanced__Coverage__Restriction.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Enhanced__Coverage__Restriction;
current_location.update_lineno(14597);
/* DIAMETER_Types.ttcn, line 14597 */
const_c__AVP__Code__DCA__3GPP__Charged__Party.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Charged__Party;
current_location.update_lineno(14599);
/* DIAMETER_Types.ttcn, line 14599 */
const_c__AVP__Code__DCA__3GPP__PDN__Connection__Charging__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PDN__Connection__Charging__ID;
current_location.update_lineno(14601);
/* DIAMETER_Types.ttcn, line 14601 */
const_c__AVP__Code__CxDx__3GPP__User__Data__Already__Available.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__User__Data__Already__Available;
current_location.update_lineno(14603);
/* DIAMETER_Types.ttcn, line 14603 */
const_c__AVP__Code__PCC__3GPP__Security__Parameter__Index.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Security__Parameter__Index;
current_location.update_lineno(14605);
/* DIAMETER_Types.ttcn, line 14605 */
const_c__AVP__Code__AAA__3GPP__MME__Number__for__MT__SMS.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__MME__Number__for__MT__SMS;
current_location.update_lineno(14607);
/* DIAMETER_Types.ttcn, line 14607 */
const_c__AVP__Code__PCC__3GPP__Traffic__Steering__Policy__Identifier__UL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Traffic__Steering__Policy__Identifier__UL;
current_location.update_lineno(14609);
/* DIAMETER_Types.ttcn, line 14609 */
const_c__AVP__Code__DCC__NONE__CC__Correlation__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Correlation__Id;
current_location.update_lineno(14611);
/* DIAMETER_Types.ttcn, line 14611 */
const_c__AVP__Code__MIPv4__NONE__MIP__Home__Agent__Host.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Home__Agent__Host;
current_location.update_lineno(14613);
/* DIAMETER_Types.ttcn, line 14613 */
const_c__AVP__Code__BASE__NONE__Route__Record.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Route__Record;
current_location.update_lineno(14615);
/* DIAMETER_Types.ttcn, line 14615 */
const_c__AVP__Code__DCA__3GPP__SM__User__Data__Header.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SM__User__Data__Header;
current_location.update_lineno(14617);
/* DIAMETER_Types.ttcn, line 14617 */
const_c__AVP__Code__AAA__3GPP__Carrier__Frequency.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Carrier__Frequency;
current_location.update_lineno(14619);
/* DIAMETER_Types.ttcn, line 14619 */
const_c__AVP__Code__DCA__3GPP__MMTel__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MMTel__Information;
current_location.update_lineno(14621);
/* DIAMETER_Types.ttcn, line 14621 */
const_c__AVP__Code__CxDx__3GPP__Mandatory__Capability.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Mandatory__Capability;
current_location.update_lineno(14623);
/* DIAMETER_Types.ttcn, line 14623 */
const_c__AVP__Code__AAA__3GPP__Trace__NE__Type__List.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Trace__NE__Type__List;
current_location.update_lineno(14625);
/* DIAMETER_Types.ttcn, line 14625 */
const_c__AVP__Code__DCA__3GPP__Charging__Characteristics__Selection__Mode.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Charging__Characteristics__Selection__Mode;
current_location.update_lineno(14627);
/* DIAMETER_Types.ttcn, line 14627 */
const_c__AVP__Code__DNAS__NONE__Port__Limit.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Port__Limit;
current_location.update_lineno(14629);
/* DIAMETER_Types.ttcn, line 14629 */
const_c__AVP__Code__MIPv6__NONE__MIP6__Feature__Vector.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv6__NONE__MIP6__Feature__Vector;
current_location.update_lineno(14631);
/* DIAMETER_Types.ttcn, line 14631 */
const_c__AVP__Code__DCC__NONE__Multiple__Services__Credit__Control.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Multiple__Services__Credit__Control;
current_location.update_lineno(14633);
/* DIAMETER_Types.ttcn, line 14633 */
const_c__AVP__Code__AAA__3GPP__All__APN__Configurations__Included__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__All__APN__Configurations__Included__Indicator;
current_location.update_lineno(14635);
/* DIAMETER_Types.ttcn, line 14635 */
const_c__AVP__Code__AAA__3GPP__NOR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__NOR__Flags;
current_location.update_lineno(14637);
/* DIAMETER_Types.ttcn, line 14637 */
const_c__AVP__Code__DCA__3GPP__Message__ID.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Message__ID;
current_location.update_lineno(14639);
/* DIAMETER_Types.ttcn, line 14639 */
const_c__AVP__Code__GI__3GPP__3GPP__MS__TimeZone.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__MS__TimeZone;
current_location.update_lineno(14641);
/* DIAMETER_Types.ttcn, line 14641 */
const_c__AVP__Code__AAA__3GPP__External__Client.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__External__Client;
current_location.update_lineno(14643);
/* DIAMETER_Types.ttcn, line 14643 */
const_c__AVP__Code__DCA__3GPP__Charge__Reason__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Charge__Reason__Code;
current_location.update_lineno(14645);
/* DIAMETER_Types.ttcn, line 14645 */
const_c__AVP__Code__BASE__NONE__Authorization__Lifetime.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Authorization__Lifetime;
current_location.update_lineno(14647);
/* DIAMETER_Types.ttcn, line 14647 */
const_c__AVP__Code__AAA__3GPP__TWAN__PCO.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__TWAN__PCO;
current_location.update_lineno(14649);
/* DIAMETER_Types.ttcn, line 14649 */
const_c__AVP__Code__DCA__3GPP__PoC__Change__Conditions.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__Change__Conditions;
current_location.update_lineno(14651);
/* DIAMETER_Types.ttcn, line 14651 */
const_c__AVP__Code__DCA__3GPP__Language.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Language;
current_location.update_lineno(14653);
/* DIAMETER_Types.ttcn, line 14653 */
const_c__AVP__Code__RX__3GPP__Extended__Min__Requested__BW__DL.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Extended__Min__Requested__BW__DL;
current_location.update_lineno(14655);
/* DIAMETER_Types.ttcn, line 14655 */
const_c__AVP__Code__DNAS__NONE__ARAP__Features.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__ARAP__Features;
current_location.update_lineno(14657);
/* DIAMETER_Types.ttcn, line 14657 */
const_c__AVP__Code__DNAS__NONE__Framed__MTU.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Framed__MTU;
current_location.update_lineno(14659);
/* DIAMETER_Types.ttcn, line 14659 */
const_c__AVP__Code__DCA__3GPP__Unit__Quota__Threshold.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Unit__Quota__Threshold;
current_location.update_lineno(14661);
/* DIAMETER_Types.ttcn, line 14661 */
const_c__AVP__Code__DNAS__NONE__Accounting__Auth__Method.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Accounting__Auth__Method;
current_location.update_lineno(14663);
/* DIAMETER_Types.ttcn, line 14663 */
const_c__AVP__Code__MIPv4__NONE__MIP__Authenticator__Offset.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__MIP__Authenticator__Offset;
current_location.update_lineno(14665);
/* DIAMETER_Types.ttcn, line 14665 */
const_c__AVP__Code__DCA__3GPP__MBMS__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MBMS__Information;
current_location.update_lineno(14667);
/* DIAMETER_Types.ttcn, line 14667 */
const_c__AVP__Code__DCA__3GPP__Bearer__Capability.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Bearer__Capability;
current_location.update_lineno(14669);
/* DIAMETER_Types.ttcn, line 14669 */
const_c__AVP__Code__RX__3GPP__Service__URN.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Service__URN;
current_location.update_lineno(14671);
/* DIAMETER_Types.ttcn, line 14671 */
const_c__AVP__Code__S6__3GPP__Supported__Services.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Supported__Services;
current_location.update_lineno(14673);
/* DIAMETER_Types.ttcn, line 14673 */
const_c__AVP__Code__DCA__3GPP__SDP__Media__Description.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SDP__Media__Description;
current_location.update_lineno(14675);
/* DIAMETER_Types.ttcn, line 14675 */
const_c__AVP__Code__MIPv4__NONE__Accounting__Output__Packets.vendor__id__NONE() = AVP__Code__NONE::avp__code__MIPv4__NONE__Accounting__Output__Packets;
current_location.update_lineno(14677);
/* DIAMETER_Types.ttcn, line 14677 */
const_c__AVP__Code__DCA__3GPP__Radio__Parameter__Set__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Radio__Parameter__Set__Info;
current_location.update_lineno(14679);
/* DIAMETER_Types.ttcn, line 14679 */
const_c__AVP__Code__PCC__3GPP__Rule__DeActivation__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Rule__DeActivation__Time;
current_location.update_lineno(14681);
/* DIAMETER_Types.ttcn, line 14681 */
const_c__AVP__Code__AAA__3GPP__Relay__Node__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Relay__Node__Indicator;
current_location.update_lineno(14683);
/* DIAMETER_Types.ttcn, line 14683 */
const_c__AVP__Code__S6__3GPP__T4__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__T4__Data;
current_location.update_lineno(14685);
/* DIAMETER_Types.ttcn, line 14685 */
const_c__AVP__Code__PCC__3GPP__Fixed__User__Location__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Fixed__User__Location__Info;
current_location.update_lineno(14687);
/* DIAMETER_Types.ttcn, line 14687 */
const_c__AVP__Code__DCA__3GPP__Coverage__Status.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Coverage__Status;
current_location.update_lineno(14689);
/* DIAMETER_Types.ttcn, line 14689 */
const_c__AVP__Code__PCC__3GPP__Online.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Online;
current_location.update_lineno(14691);
/* DIAMETER_Types.ttcn, line 14691 */
const_c__AVP__Code__PCC__3GPP__ADC__Rule__Base__Name.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__ADC__Rule__Base__Name;
current_location.update_lineno(14693);
/* DIAMETER_Types.ttcn, line 14693 */
const_c__AVP__Code__AAA__3GPP__SCEF__Realm.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SCEF__Realm;
current_location.update_lineno(14695);
/* DIAMETER_Types.ttcn, line 14695 */
const_c__AVP__Code__DCA__3GPP__MBMS__Charged__Party.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__MBMS__Charged__Party;
current_location.update_lineno(14697);
/* DIAMETER_Types.ttcn, line 14697 */
const_c__AVP__Code__S6__3GPP__Requested__Validity__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Requested__Validity__Time;
current_location.update_lineno(14699);
/* DIAMETER_Types.ttcn, line 14699 */
const_c__AVP__Code__DCC__NONE__CC__Request__Number.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Request__Number;
current_location.update_lineno(14701);
/* DIAMETER_Types.ttcn, line 14701 */
const_c__AVP__Code__DCA__3GPP__AoC__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__AoC__Information;
current_location.update_lineno(14703);
/* DIAMETER_Types.ttcn, line 14703 */
const_c__AVP__Code__CxDx__3GPP__Supported__Features.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Supported__Features;
current_location.update_lineno(14705);
/* DIAMETER_Types.ttcn, line 14705 */
const_c__AVP__Code__AAA__3GPP__Local__Time__Zone.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Local__Time__Zone;
current_location.update_lineno(14707);
/* DIAMETER_Types.ttcn, line 14707 */
const_c__AVP__Code__AAA__3GPP__GERAN__Vector.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__GERAN__Vector;
current_location.update_lineno(14709);
/* DIAMETER_Types.ttcn, line 14709 */
const_c__AVP__Code__CxDx__3GPP__Call__ID__SIP__Header.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Call__ID__SIP__Header;
current_location.update_lineno(14711);
/* DIAMETER_Types.ttcn, line 14711 */
const_c__AVP__Code__DCA__3GPP__Online__Charging__Flag.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Online__Charging__Flag;
current_location.update_lineno(14713);
/* DIAMETER_Types.ttcn, line 14713 */
const_c__AVP__Code__DCA__3GPP__Number__of__Messages__Sent.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Number__of__Messages__Sent;
current_location.update_lineno(14715);
/* DIAMETER_Types.ttcn, line 14715 */
const_c__AVP__Code__AAA__3GPP__EPS__Subscribed__QoS__Profile.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__EPS__Subscribed__QoS__Profile;
current_location.update_lineno(14717);
/* DIAMETER_Types.ttcn, line 14717 */
const_c__AVP__Code__GI__3GPP__3GPP__Session__Stop__Indicator.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__Session__Stop__Indicator;
current_location.update_lineno(14719);
/* DIAMETER_Types.ttcn, line 14719 */
const_c__AVP__Code__AAA__3GPP__GPRS__Subscription__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__GPRS__Subscription__Data;
current_location.update_lineno(14721);
/* DIAMETER_Types.ttcn, line 14721 */
const_c__AVP__Code__GI__3GPP__3GPP__GPRS__Negotiated__QoS__Profile.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__GPRS__Negotiated__QoS__Profile;
current_location.update_lineno(14723);
/* DIAMETER_Types.ttcn, line 14723 */
const_c__AVP__Code__DCA__3GPP__Access__Transfer__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Access__Transfer__Type;
current_location.update_lineno(14725);
/* DIAMETER_Types.ttcn, line 14725 */
const_c__AVP__Code__DNAS__NONE__Called__Station__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Called__Station__Id;
current_location.update_lineno(14727);
/* DIAMETER_Types.ttcn, line 14727 */
const_c__AVP__Code__DCA__3GPP__Inter__UE__Transfer.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Inter__UE__Transfer;
current_location.update_lineno(14729);
/* DIAMETER_Types.ttcn, line 14729 */
const_c__AVP__Code__DCC__NONE__Cost__Unit.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__Cost__Unit;
current_location.update_lineno(14731);
/* DIAMETER_Types.ttcn, line 14731 */
const_c__AVP__Code__BASE__NONE__Accounting__Realtime__Required.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Accounting__Realtime__Required;
current_location.update_lineno(14733);
/* DIAMETER_Types.ttcn, line 14733 */
const_c__AVP__Code__BASE__NONE__Termination__Cause.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Termination__Cause;
current_location.update_lineno(14735);
/* DIAMETER_Types.ttcn, line 14735 */
const_c__AVP__Code__DCA__3GPP__Received__Talk__Burst__Volume.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Received__Talk__Burst__Volume;
current_location.update_lineno(14737);
/* DIAMETER_Types.ttcn, line 14737 */
const_c__AVP__Code__DCA__3GPP__Rate__Control__Max__Rate.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Rate__Control__Max__Rate;
current_location.update_lineno(14739);
/* DIAMETER_Types.ttcn, line 14739 */
const_c__AVP__Code__DCA__3GPP__Class__Identifier.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Class__Identifier;
current_location.update_lineno(14741);
/* DIAMETER_Types.ttcn, line 14741 */
const_c__AVP__Code__GI__3GPP__3GPP__Allocate__IP__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__GI__3GPP__3GPP__Allocate__IP__Type;
current_location.update_lineno(14743);
/* DIAMETER_Types.ttcn, line 14743 */
const_c__AVP__Code__AAA__3GPP__SM__Back__Off__Timer.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SM__Back__Off__Timer;
current_location.update_lineno(14745);
/* DIAMETER_Types.ttcn, line 14745 */
const_c__AVP__Code__RX__3GPP__Specific__Action.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__Specific__Action;
current_location.update_lineno(14747);
/* DIAMETER_Types.ttcn, line 14747 */
const_c__AVP__Code__S6__3GPP__Maximum__Detection__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Maximum__Detection__Time;
current_location.update_lineno(14749);
/* DIAMETER_Types.ttcn, line 14749 */
const_c__AVP__Code__DNAS__NONE__Login__TCP__Port.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Login__TCP__Port;
current_location.update_lineno(14751);
/* DIAMETER_Types.ttcn, line 14751 */
const_c__AVP__Code__DNAS__NONE__Password__Retry.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__Password__Retry;
current_location.update_lineno(14753);
/* DIAMETER_Types.ttcn, line 14753 */
const_c__AVP__Code__DCA__3GPP__Time__Stamps.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Time__Stamps;
current_location.update_lineno(14755);
/* DIAMETER_Types.ttcn, line 14755 */
const_c__AVP__Code__DCA__3GPP__Base__Time__Interval.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Base__Time__Interval;
current_location.update_lineno(14757);
/* DIAMETER_Types.ttcn, line 14757 */
const_c__AVP__Code__DCA__3GPP__UWAN__User__Location__Info.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__UWAN__User__Location__Info;
current_location.update_lineno(14759);
/* DIAMETER_Types.ttcn, line 14759 */
const_c__AVP__Code__DCA__3GPP__ProSe__Role__Of__UE.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ProSe__Role__Of__UE;
current_location.update_lineno(14761);
/* DIAMETER_Types.ttcn, line 14761 */
const_c__AVP__Code__PCC__3GPP__RAT__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__RAT__Type;
current_location.update_lineno(14763);
/* DIAMETER_Types.ttcn, line 14763 */
const_c__AVP__Code__AAA__3GPP__Ext__PDP__Address.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Ext__PDP__Address;
current_location.update_lineno(14765);
/* DIAMETER_Types.ttcn, line 14765 */
const_c__AVP__Code__DCA__3GPP__PoC__Session__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__PoC__Session__Type;
current_location.update_lineno(14767);
/* DIAMETER_Types.ttcn, line 14767 */
const_c__AVP__Code__DCA__3GPP__ISUP__Cause.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__ISUP__Cause;
current_location.update_lineno(14769);
/* DIAMETER_Types.ttcn, line 14769 */
const_c__AVP__Code__RX__3GPP__AF__Signalling__Protocol.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__RX__3GPP__AF__Signalling__Protocol;
current_location.update_lineno(14771);
/* DIAMETER_Types.ttcn, line 14771 */
const_c__AVP__Code__AAA__3GPP__Adjacent__PLMNs.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Adjacent__PLMNs;
current_location.update_lineno(14773);
/* DIAMETER_Types.ttcn, line 14773 */
const_c__AVP__Code__S6__3GPP__Service__Result__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__S6__3GPP__Service__Result__Code;
current_location.update_lineno(14775);
/* DIAMETER_Types.ttcn, line 14775 */
const_c__AVP__Code__AAA__3GPP__SGSN__Location__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__SGSN__Location__Information;
current_location.update_lineno(14777);
/* DIAMETER_Types.ttcn, line 14777 */
const_c__AVP__Code__DCA__3GPP__Authorised__QoS.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Authorised__QoS;
current_location.update_lineno(14779);
/* DIAMETER_Types.ttcn, line 14779 */
const_c__AVP__Code__DCA__3GPP__Time__First__Transmission.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Time__First__Transmission;
current_location.update_lineno(14781);
/* DIAMETER_Types.ttcn, line 14781 */
const_c__AVP__Code__DCA__3GPP__Stop__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Stop__Time;
current_location.update_lineno(14783);
/* DIAMETER_Types.ttcn, line 14783 */
const_c__AVP__Code__CxDx__3GPP__Reason__Code.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Reason__Code;
current_location.update_lineno(14785);
/* DIAMETER_Types.ttcn, line 14785 */
const_c__AVP__Code__PCC__3GPP__Pre__emption__Vulnerability.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Pre__emption__Vulnerability;
current_location.update_lineno(14787);
/* DIAMETER_Types.ttcn, line 14787 */
const_c__AVP__Code__AAA__3GPP__Equivalent__PLMN__List.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__Equivalent__PLMN__List;
current_location.update_lineno(14789);
/* DIAMETER_Types.ttcn, line 14789 */
const_c__AVP__Code__PCC__3GPP__Default__Access.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__Default__Access;
current_location.update_lineno(14791);
/* DIAMETER_Types.ttcn, line 14791 */
const_c__AVP__Code__CxDx__3GPP__Supported__Applications.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__CxDx__3GPP__Supported__Applications;
current_location.update_lineno(14793);
/* DIAMETER_Types.ttcn, line 14793 */
const_c__AVP__Code__BASE__NONE__Class.vendor__id__NONE() = AVP__Code__NONE::avp__code__BASE__NONE__Class;
current_location.update_lineno(14795);
/* DIAMETER_Types.ttcn, line 14795 */
const_c__AVP__Code__DNAS__NONE__ARAP__Challenge__Response.vendor__id__NONE() = AVP__Code__NONE::avp__code__DNAS__NONE__ARAP__Challenge__Response;
current_location.update_lineno(14797);
/* DIAMETER_Types.ttcn, line 14797 */
const_c__AVP__Code__DCA__3GPP__SM__Message__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__SM__Message__Type;
current_location.update_lineno(14799);
/* DIAMETER_Types.ttcn, line 14799 */
const_c__AVP__Code__DCC__NONE__CC__Sub__Session__Id.vendor__id__NONE() = AVP__Code__NONE::avp__code__DCC__NONE__CC__Sub__Session__Id;
current_location.update_lineno(14801);
/* DIAMETER_Types.ttcn, line 14801 */
const_c__AVP__Code__AAA__3GPP__IDR__Flags.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__IDR__Flags;
current_location.update_lineno(14803);
/* DIAMETER_Types.ttcn, line 14803 */
const_c__AVP__Code__PCC__3GPP__PS__to__CS__Session__Continuity.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__PCC__3GPP__PS__to__CS__Session__Continuity;
current_location.update_lineno(14805);
/* DIAMETER_Types.ttcn, line 14805 */
const_c__AVP__Code__AAA__3GPP__V2X__Subscription__Data.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__V2X__Subscription__Data;
current_location.update_lineno(14807);
/* DIAMETER_Types.ttcn, line 14807 */
const_c__AVP__Code__DCA__3GPP__Refund__Information.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Refund__Information;
current_location.update_lineno(14809);
/* DIAMETER_Types.ttcn, line 14809 */
const_c__AVP__Code__DCA__3GPP__Rate__Element.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Rate__Element;
current_location.update_lineno(14811);
/* DIAMETER_Types.ttcn, line 14811 */
const_c__AVP__Code__AAA__3GPP__PDP__Type.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__PDP__Type;
current_location.update_lineno(14813);
/* DIAMETER_Types.ttcn, line 14813 */
const_c__AVP__Code__AAA__3GPP__AMBR.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__AAA__3GPP__AMBR;
current_location.update_lineno(14815);
/* DIAMETER_Types.ttcn, line 14815 */
const_c__AVP__Code__DCA__3GPP__Submission__Time.vendor__id__3GPP() = AVP__Code__3GPP::avp__code__DCA__3GPP__Submission__Time;
}


} /* end of namespace */
