// This C++ header 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.

#ifndef RTP__Emulation_HH
#define RTP__Emulation_HH

#ifdef TITAN_RUNTIME_2
#error Generated code does not match with used runtime.\
 Code was generated without -R option but -DTITAN_RUNTIME_2 was used.
#endif

/* Header file includes */

#include <TTCN3.hh>
#include "RTP_CodecPort_CtrlFunct.hh"
#include "IuUP_Emulation.hh"

#if TTCN3_VERSION != 110100
#error Version mismatch detected.\
 Please check the version of the TTCN-3 compiler and the base library.\
 Run make clean and rebuild the project if the version of the compiler changed recently.
#endif

#ifndef LINUX
#error This file should be compiled on LINUX
#endif

#undef RTP__Emulation_HH
#endif

namespace RTP__Emulation {

/* Forward declarations of classes */

class RtpemConfig_tx__payloads;
class RtpemConfig_tx__payloads_template;
class RtpemConfigPayload;
class RtpemConfigPayload_template;
class RtpemConfig_rx__payloads;
class RtpemConfig_rx__payloads_template;
class RtpemConfig;
class RtpemConfig_template;
class RtpemStats;
class RtpemStats_template;
class RtpemMode;
class RtpemMode_template;
class RTPEM__bind_call;
class RTPEM__bind_call_redirect;
class RTPEM__bind_reply;
class RTPEM__bind_reply_redirect;
class RTPEM__bind_template;
class RTPEM__connect_call;
class RTPEM__connect_call_redirect;
class RTPEM__connect_reply;
class RTPEM__connect_reply_redirect;
class RTPEM__connect_template;
class RTPEM__mode_call;
class RTPEM__mode_call_redirect;
class RTPEM__mode_reply;
class RTPEM__mode_reply_redirect;
class RTPEM__mode_template;
class RTPEM__configure_call;
class RTPEM__configure_call_redirect;
class RTPEM__configure_reply;
class RTPEM__configure_reply_redirect;
class RTPEM__configure_template;
class RTPEM__stats__get_call;
class RTPEM__stats__get_call_redirect;
class RTPEM__stats__get_reply;
class RTPEM__stats__get_reply_redirect;
class RTPEM__stats__get_template;
class RTPEM__conn__refuse__expect_call;
class RTPEM__conn__refuse__expect_call_redirect;
class RTPEM__conn__refuse__expect_reply;
class RTPEM__conn__refuse__expect_reply_redirect;
class RTPEM__conn__refuse__expect_template;
class RTPEM__conn__refuse__received_call;
class RTPEM__conn__refuse__received_call_redirect;
class RTPEM__conn__refuse__received_reply;
class RTPEM__conn__refuse__received_reply_redirect;
class RTPEM__conn__refuse__received_template;
class RTPEM__CTRL__PT;
class RTPEM__DATA__PT;

} /* end of namespace */

#ifndef RTP__Emulation_HH
#define RTP__Emulation_HH

namespace RTP__Emulation {

/* Type definitions */

typedef COMPONENT RTP__Emulation__CT;
typedef COMPONENT_template RTP__Emulation__CT_template;

/* Class definitions */

class RtpemConfig_tx__payloads : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
RtpemConfigPayload **value_elements;
} *val_ptr;

static const RtpemConfigPayload UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const RtpemConfig_tx__payloads& other_value);

public:
  typedef RtpemConfigPayload of_type;
RtpemConfig_tx__payloads();
RtpemConfig_tx__payloads(null_type other_value);
RtpemConfig_tx__payloads(const RtpemConfig_tx__payloads& other_value);
~RtpemConfig_tx__payloads();

void clean_up();
RtpemConfig_tx__payloads& operator=(null_type other_value);
RtpemConfig_tx__payloads& operator=(const RtpemConfig_tx__payloads& other_value);

boolean operator==(null_type other_value) const;
boolean operator==(const RtpemConfig_tx__payloads& other_value) const;
inline boolean operator!=(null_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const RtpemConfig_tx__payloads& other_value) const { return !(*this == other_value); }

RtpemConfigPayload& operator[](int index_value);
RtpemConfigPayload& operator[](const INTEGER& index_value);
const RtpemConfigPayload& operator[](int index_value) const;
const RtpemConfigPayload& operator[](const INTEGER& index_value) const;

RtpemConfig_tx__payloads operator<<=(int rotate_count) const;
RtpemConfig_tx__payloads operator<<=(const INTEGER& rotate_count) const;
RtpemConfig_tx__payloads operator>>=(int rotate_count) const;
RtpemConfig_tx__payloads operator>>=(const INTEGER& rotate_count) const;

RtpemConfig_tx__payloads operator+(const RtpemConfig_tx__payloads& other_value) const;

RtpemConfig_tx__payloads substr(int index, int returncount) const;

RtpemConfig_tx__payloads replace(int index, int len, const RtpemConfig_tx__payloads& repl) const;

RtpemConfig_tx__payloads replace(int index, int len, const RtpemConfig_tx__payloads_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RtpemConfig_tx__payloads_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
RtpemConfigPayload_template **value_elements;
} single_value;
struct {
unsigned int n_values;
RtpemConfig_tx__payloads_template *list_value;
} value_list;
struct {
RtpemConfig_tx__payloads_template* precondition;
RtpemConfig_tx__payloads_template* implied_template;
} implication_;
dynmatch_struct<RtpemConfig_tx__payloads>* dyn_match;
};
void copy_value(const RtpemConfig_tx__payloads& other_value);
void copy_template(const RtpemConfig_tx__payloads_template& other_value);
static boolean match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);

public:
RtpemConfig_tx__payloads_template();
RtpemConfig_tx__payloads_template(template_sel other_value);
RtpemConfig_tx__payloads_template(null_type other_value);
RtpemConfig_tx__payloads_template(const RtpemConfig_tx__payloads& other_value);
RtpemConfig_tx__payloads_template(const OPTIONAL<RtpemConfig_tx__payloads>& other_value);
RtpemConfig_tx__payloads_template(RtpemConfig_tx__payloads_template* p_precondition, RtpemConfig_tx__payloads_template* p_implied_template);
RtpemConfig_tx__payloads_template(Dynamic_Match_Interface<RtpemConfig_tx__payloads>* p_dyn_match);
RtpemConfig_tx__payloads_template(const RtpemConfig_tx__payloads_template& other_value);
~RtpemConfig_tx__payloads_template();

void clean_up();
RtpemConfig_tx__payloads_template& operator=(template_sel other_value);
RtpemConfig_tx__payloads_template& operator=(null_type other_value);
RtpemConfig_tx__payloads_template& operator=(const RtpemConfig_tx__payloads& other_value);
RtpemConfig_tx__payloads_template& operator=(const OPTIONAL<RtpemConfig_tx__payloads>& other_value);
RtpemConfig_tx__payloads_template& operator=(const RtpemConfig_tx__payloads_template& other_value);

RtpemConfigPayload_template& operator[](int index_value);
RtpemConfigPayload_template& operator[](const INTEGER& index_value);
const RtpemConfigPayload_template& operator[](int index_value) const;
const RtpemConfigPayload_template& operator[](const INTEGER& index_value) const;

void set_size(int new_size);
int n_elem() const;
int size_of(boolean is_size) const;
inline int size_of() const { return size_of(TRUE); }
inline int lengthof() const { return size_of(FALSE); }
boolean match(const RtpemConfig_tx__payloads& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
RtpemConfig_tx__payloads valueof() const;
RtpemConfig_tx__payloads substr(int index, int returncount) const;

RtpemConfig_tx__payloads replace(int index, int len, const RtpemConfig_tx__payloads_template& repl) const;

RtpemConfig_tx__payloads replace(int index, int len, const RtpemConfig_tx__payloads& repl) const;

void set_type(template_sel template_type, unsigned int list_length);
RtpemConfig_tx__payloads_template& list_item(unsigned int list_index);
void log() const;
void log_match(const RtpemConfig_tx__payloads& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean get_istemplate_kind(const char* type) const;
};

class RtpemConfigPayload {
  INTEGER field_payload__type;
  OPTIONAL< OCTETSTRING > field_fixed__payload;
public:
  RtpemConfigPayload();
  RtpemConfigPayload(const INTEGER& par_payload__type,
    const OPTIONAL< OCTETSTRING >& par_fixed__payload);
  RtpemConfigPayload(const RtpemConfigPayload& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RtpemConfigPayload& operator=(const RtpemConfigPayload& other_value);
  boolean operator==(const RtpemConfigPayload& other_value) const;
  inline boolean operator!=(const RtpemConfigPayload& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline INTEGER& payload__type()
    {return field_payload__type;}
  inline const INTEGER& payload__type() const
    {return field_payload__type;}
  inline OPTIONAL< OCTETSTRING >& fixed__payload()
    {return field_fixed__payload;}
  inline const OPTIONAL< OCTETSTRING >& fixed__payload() const
    {return field_fixed__payload;}
  int size_of() const;
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
};

class RtpemConfigPayload_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RtpemConfigPayload_template *list_value;
} value_list;
struct {
RtpemConfigPayload_template* precondition;
RtpemConfigPayload_template* implied_template;
} implication_;
dynmatch_struct<RtpemConfigPayload>* dyn_match;
};

void set_specific();
void copy_value(const RtpemConfigPayload& other_value);
void copy_template(const RtpemConfigPayload_template& other_value);

public:
RtpemConfigPayload_template();
RtpemConfigPayload_template(template_sel other_value);
RtpemConfigPayload_template(const RtpemConfigPayload& other_value);
RtpemConfigPayload_template(const OPTIONAL<RtpemConfigPayload>& other_value);
RtpemConfigPayload_template(RtpemConfigPayload_template* p_precondition, RtpemConfigPayload_template* p_implied_template);
RtpemConfigPayload_template(Dynamic_Match_Interface<RtpemConfigPayload>* p_dyn_match);
RtpemConfigPayload_template(const RtpemConfigPayload_template& other_value);
~RtpemConfigPayload_template();
RtpemConfigPayload_template& operator=(template_sel other_value);
RtpemConfigPayload_template& operator=(const RtpemConfigPayload& other_value);
RtpemConfigPayload_template& operator=(const OPTIONAL<RtpemConfigPayload>& other_value);
RtpemConfigPayload_template& operator=(const RtpemConfigPayload_template& other_value);
boolean match(const RtpemConfigPayload& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RtpemConfigPayload valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RtpemConfigPayload_template& list_item(unsigned int list_index) const;
INTEGER_template& payload__type();
const INTEGER_template& payload__type() const;
OCTETSTRING_template& fixed__payload();
const OCTETSTRING_template& fixed__payload() const;
int size_of() const;
void log() const;
void log_match(const RtpemConfigPayload& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class RtpemConfig_rx__payloads : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
RtpemConfigPayload **value_elements;
} *val_ptr;

static const RtpemConfigPayload UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const RtpemConfig_rx__payloads& other_value);

public:
  typedef RtpemConfigPayload of_type;
RtpemConfig_rx__payloads();
RtpemConfig_rx__payloads(null_type other_value);
RtpemConfig_rx__payloads(const RtpemConfig_rx__payloads& other_value);
~RtpemConfig_rx__payloads();

void clean_up();
RtpemConfig_rx__payloads& operator=(null_type other_value);
RtpemConfig_rx__payloads& operator=(const RtpemConfig_rx__payloads& other_value);

boolean operator==(null_type other_value) const;
boolean operator==(const RtpemConfig_rx__payloads& other_value) const;
inline boolean operator!=(null_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const RtpemConfig_rx__payloads& other_value) const { return !(*this == other_value); }

RtpemConfigPayload& operator[](int index_value);
RtpemConfigPayload& operator[](const INTEGER& index_value);
const RtpemConfigPayload& operator[](int index_value) const;
const RtpemConfigPayload& operator[](const INTEGER& index_value) const;

RtpemConfig_rx__payloads operator<<=(int rotate_count) const;
RtpemConfig_rx__payloads operator<<=(const INTEGER& rotate_count) const;
RtpemConfig_rx__payloads operator>>=(int rotate_count) const;
RtpemConfig_rx__payloads operator>>=(const INTEGER& rotate_count) const;

RtpemConfig_rx__payloads operator+(const RtpemConfig_rx__payloads& other_value) const;

RtpemConfig_rx__payloads substr(int index, int returncount) const;

RtpemConfig_rx__payloads replace(int index, int len, const RtpemConfig_rx__payloads& repl) const;

RtpemConfig_rx__payloads replace(int index, int len, const RtpemConfig_rx__payloads_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RtpemConfig_rx__payloads_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
RtpemConfigPayload_template **value_elements;
} single_value;
struct {
unsigned int n_values;
RtpemConfig_rx__payloads_template *list_value;
} value_list;
struct {
RtpemConfig_rx__payloads_template* precondition;
RtpemConfig_rx__payloads_template* implied_template;
} implication_;
dynmatch_struct<RtpemConfig_rx__payloads>* dyn_match;
};
void copy_value(const RtpemConfig_rx__payloads& other_value);
void copy_template(const RtpemConfig_rx__payloads_template& other_value);
static boolean match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);

public:
RtpemConfig_rx__payloads_template();
RtpemConfig_rx__payloads_template(template_sel other_value);
RtpemConfig_rx__payloads_template(null_type other_value);
RtpemConfig_rx__payloads_template(const RtpemConfig_rx__payloads& other_value);
RtpemConfig_rx__payloads_template(const OPTIONAL<RtpemConfig_rx__payloads>& other_value);
RtpemConfig_rx__payloads_template(RtpemConfig_rx__payloads_template* p_precondition, RtpemConfig_rx__payloads_template* p_implied_template);
RtpemConfig_rx__payloads_template(Dynamic_Match_Interface<RtpemConfig_rx__payloads>* p_dyn_match);
RtpemConfig_rx__payloads_template(const RtpemConfig_rx__payloads_template& other_value);
~RtpemConfig_rx__payloads_template();

void clean_up();
RtpemConfig_rx__payloads_template& operator=(template_sel other_value);
RtpemConfig_rx__payloads_template& operator=(null_type other_value);
RtpemConfig_rx__payloads_template& operator=(const RtpemConfig_rx__payloads& other_value);
RtpemConfig_rx__payloads_template& operator=(const OPTIONAL<RtpemConfig_rx__payloads>& other_value);
RtpemConfig_rx__payloads_template& operator=(const RtpemConfig_rx__payloads_template& other_value);

RtpemConfigPayload_template& operator[](int index_value);
RtpemConfigPayload_template& operator[](const INTEGER& index_value);
const RtpemConfigPayload_template& operator[](int index_value) const;
const RtpemConfigPayload_template& operator[](const INTEGER& index_value) const;

void set_size(int new_size);
int n_elem() const;
int size_of(boolean is_size) const;
inline int size_of() const { return size_of(TRUE); }
inline int lengthof() const { return size_of(FALSE); }
boolean match(const RtpemConfig_rx__payloads& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
RtpemConfig_rx__payloads valueof() const;
RtpemConfig_rx__payloads substr(int index, int returncount) const;

RtpemConfig_rx__payloads replace(int index, int len, const RtpemConfig_rx__payloads_template& repl) const;

RtpemConfig_rx__payloads replace(int index, int len, const RtpemConfig_rx__payloads& repl) const;

void set_type(template_sel template_type, unsigned int list_length);
RtpemConfig_rx__payloads_template& list_item(unsigned int list_index);
void log() const;
void log_match(const RtpemConfig_rx__payloads& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean get_istemplate_kind(const char* type) const;
};

class RtpemConfig {
  INTEGER field_tx__samplerate__hz;
  INTEGER field_tx__duration__ms;
  BITSTRING field_tx__ssrc;
  RtpemConfig_tx__payloads field_tx__payloads;
  RtpemConfig_rx__payloads field_rx__payloads;
  BOOLEAN field_iuup__mode;
  IuUP__Emulation::IuUP__Config field_iuup__cfg;
public:
  RtpemConfig();
  RtpemConfig(const INTEGER& par_tx__samplerate__hz,
    const INTEGER& par_tx__duration__ms,
    const BITSTRING& par_tx__ssrc,
    const RtpemConfig_tx__payloads& par_tx__payloads,
    const RtpemConfig_rx__payloads& par_rx__payloads,
    const BOOLEAN& par_iuup__mode,
    const IuUP__Emulation::IuUP__Config& par_iuup__cfg);
  RtpemConfig(const RtpemConfig& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RtpemConfig& operator=(const RtpemConfig& other_value);
  boolean operator==(const RtpemConfig& other_value) const;
  inline boolean operator!=(const RtpemConfig& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline INTEGER& tx__samplerate__hz()
    {return field_tx__samplerate__hz;}
  inline const INTEGER& tx__samplerate__hz() const
    {return field_tx__samplerate__hz;}
  inline INTEGER& tx__duration__ms()
    {return field_tx__duration__ms;}
  inline const INTEGER& tx__duration__ms() const
    {return field_tx__duration__ms;}
  inline BITSTRING& tx__ssrc()
    {return field_tx__ssrc;}
  inline const BITSTRING& tx__ssrc() const
    {return field_tx__ssrc;}
  inline RtpemConfig_tx__payloads& tx__payloads()
    {return field_tx__payloads;}
  inline const RtpemConfig_tx__payloads& tx__payloads() const
    {return field_tx__payloads;}
  inline RtpemConfig_rx__payloads& rx__payloads()
    {return field_rx__payloads;}
  inline const RtpemConfig_rx__payloads& rx__payloads() const
    {return field_rx__payloads;}
  inline BOOLEAN& iuup__mode()
    {return field_iuup__mode;}
  inline const BOOLEAN& iuup__mode() const
    {return field_iuup__mode;}
  inline IuUP__Emulation::IuUP__Config& iuup__cfg()
    {return field_iuup__cfg;}
  inline const IuUP__Emulation::IuUP__Config& iuup__cfg() const
    {return field_iuup__cfg;}
  inline int size_of() const
    {return 7;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
};

class RtpemConfig_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RtpemConfig_template *list_value;
} value_list;
struct {
RtpemConfig_template* precondition;
RtpemConfig_template* implied_template;
} implication_;
dynmatch_struct<RtpemConfig>* dyn_match;
};

void set_specific();
void copy_value(const RtpemConfig& other_value);
void copy_template(const RtpemConfig_template& other_value);

public:
RtpemConfig_template();
RtpemConfig_template(template_sel other_value);
RtpemConfig_template(const RtpemConfig& other_value);
RtpemConfig_template(const OPTIONAL<RtpemConfig>& other_value);
RtpemConfig_template(RtpemConfig_template* p_precondition, RtpemConfig_template* p_implied_template);
RtpemConfig_template(Dynamic_Match_Interface<RtpemConfig>* p_dyn_match);
RtpemConfig_template(const RtpemConfig_template& other_value);
~RtpemConfig_template();
RtpemConfig_template& operator=(template_sel other_value);
RtpemConfig_template& operator=(const RtpemConfig& other_value);
RtpemConfig_template& operator=(const OPTIONAL<RtpemConfig>& other_value);
RtpemConfig_template& operator=(const RtpemConfig_template& other_value);
boolean match(const RtpemConfig& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RtpemConfig valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RtpemConfig_template& list_item(unsigned int list_index) const;
INTEGER_template& tx__samplerate__hz();
const INTEGER_template& tx__samplerate__hz() const;
INTEGER_template& tx__duration__ms();
const INTEGER_template& tx__duration__ms() const;
BITSTRING_template& tx__ssrc();
const BITSTRING_template& tx__ssrc() const;
RtpemConfig_tx__payloads_template& tx__payloads();
const RtpemConfig_tx__payloads_template& tx__payloads() const;
RtpemConfig_rx__payloads_template& rx__payloads();
const RtpemConfig_rx__payloads_template& rx__payloads() const;
BOOLEAN_template& iuup__mode();
const BOOLEAN_template& iuup__mode() const;
IuUP__Emulation::IuUP__Config_template& iuup__cfg();
const IuUP__Emulation::IuUP__Config_template& iuup__cfg() const;
int size_of() const;
void log() const;
void log_match(const RtpemConfig& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class RtpemStats {
  INTEGER field_num__pkts__tx;
  INTEGER field_bytes__payload__tx;
  INTEGER field_num__pkts__rx;
  INTEGER field_bytes__payload__rx;
  INTEGER field_num__pkts__rx__err__seq;
  INTEGER field_num__pkts__rx__err__ts;
  INTEGER field_num__pkts__rx__err__pt;
  INTEGER field_num__pkts__rx__err__disabled;
  INTEGER field_num__pkts__rx__err__payload;
public:
  RtpemStats();
  RtpemStats(const INTEGER& par_num__pkts__tx,
    const INTEGER& par_bytes__payload__tx,
    const INTEGER& par_num__pkts__rx,
    const INTEGER& par_bytes__payload__rx,
    const INTEGER& par_num__pkts__rx__err__seq,
    const INTEGER& par_num__pkts__rx__err__ts,
    const INTEGER& par_num__pkts__rx__err__pt,
    const INTEGER& par_num__pkts__rx__err__disabled,
    const INTEGER& par_num__pkts__rx__err__payload);
  RtpemStats(const RtpemStats& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RtpemStats& operator=(const RtpemStats& other_value);
  boolean operator==(const RtpemStats& other_value) const;
  inline boolean operator!=(const RtpemStats& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline INTEGER& num__pkts__tx()
    {return field_num__pkts__tx;}
  inline const INTEGER& num__pkts__tx() const
    {return field_num__pkts__tx;}
  inline INTEGER& bytes__payload__tx()
    {return field_bytes__payload__tx;}
  inline const INTEGER& bytes__payload__tx() const
    {return field_bytes__payload__tx;}
  inline INTEGER& num__pkts__rx()
    {return field_num__pkts__rx;}
  inline const INTEGER& num__pkts__rx() const
    {return field_num__pkts__rx;}
  inline INTEGER& bytes__payload__rx()
    {return field_bytes__payload__rx;}
  inline const INTEGER& bytes__payload__rx() const
    {return field_bytes__payload__rx;}
  inline INTEGER& num__pkts__rx__err__seq()
    {return field_num__pkts__rx__err__seq;}
  inline const INTEGER& num__pkts__rx__err__seq() const
    {return field_num__pkts__rx__err__seq;}
  inline INTEGER& num__pkts__rx__err__ts()
    {return field_num__pkts__rx__err__ts;}
  inline const INTEGER& num__pkts__rx__err__ts() const
    {return field_num__pkts__rx__err__ts;}
  inline INTEGER& num__pkts__rx__err__pt()
    {return field_num__pkts__rx__err__pt;}
  inline const INTEGER& num__pkts__rx__err__pt() const
    {return field_num__pkts__rx__err__pt;}
  inline INTEGER& num__pkts__rx__err__disabled()
    {return field_num__pkts__rx__err__disabled;}
  inline const INTEGER& num__pkts__rx__err__disabled() const
    {return field_num__pkts__rx__err__disabled;}
  inline INTEGER& num__pkts__rx__err__payload()
    {return field_num__pkts__rx__err__payload;}
  inline const INTEGER& num__pkts__rx__err__payload() const
    {return field_num__pkts__rx__err__payload;}
  inline int size_of() const
    {return 9;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
};

class RtpemStats_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RtpemStats_template *list_value;
} value_list;
struct {
RtpemStats_template* precondition;
RtpemStats_template* implied_template;
} implication_;
dynmatch_struct<RtpemStats>* dyn_match;
};

void set_specific();
void copy_value(const RtpemStats& other_value);
void copy_template(const RtpemStats_template& other_value);

public:
RtpemStats_template();
RtpemStats_template(template_sel other_value);
RtpemStats_template(const RtpemStats& other_value);
RtpemStats_template(const OPTIONAL<RtpemStats>& other_value);
RtpemStats_template(RtpemStats_template* p_precondition, RtpemStats_template* p_implied_template);
RtpemStats_template(Dynamic_Match_Interface<RtpemStats>* p_dyn_match);
RtpemStats_template(const RtpemStats_template& other_value);
~RtpemStats_template();
RtpemStats_template& operator=(template_sel other_value);
RtpemStats_template& operator=(const RtpemStats& other_value);
RtpemStats_template& operator=(const OPTIONAL<RtpemStats>& other_value);
RtpemStats_template& operator=(const RtpemStats_template& other_value);
boolean match(const RtpemStats& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RtpemStats valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RtpemStats_template& list_item(unsigned int list_index) const;
INTEGER_template& num__pkts__tx();
const INTEGER_template& num__pkts__tx() const;
INTEGER_template& bytes__payload__tx();
const INTEGER_template& bytes__payload__tx() const;
INTEGER_template& num__pkts__rx();
const INTEGER_template& num__pkts__rx() const;
INTEGER_template& bytes__payload__rx();
const INTEGER_template& bytes__payload__rx() const;
INTEGER_template& num__pkts__rx__err__seq();
const INTEGER_template& num__pkts__rx__err__seq() const;
INTEGER_template& num__pkts__rx__err__ts();
const INTEGER_template& num__pkts__rx__err__ts() const;
INTEGER_template& num__pkts__rx__err__pt();
const INTEGER_template& num__pkts__rx__err__pt() const;
INTEGER_template& num__pkts__rx__err__disabled();
const INTEGER_template& num__pkts__rx__err__disabled() const;
INTEGER_template& num__pkts__rx__err__payload();
const INTEGER_template& num__pkts__rx__err__payload() const;
int size_of() const;
void log() const;
void log_match(const RtpemStats& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class RtpemMode : public Base_Type { // enum
friend class RtpemMode_template;
public:
enum enum_type { RTPEM__MODE__NONE = 0, RTPEM__MODE__TXONLY = 1, RTPEM__MODE__RXONLY = 2, RTPEM__MODE__BIDIR = 3, RTPEM__MODE__LOOPBACK = 4, UNKNOWN_VALUE = 5, UNBOUND_VALUE = 6 };
private:
enum_type enum_value;

public:
RtpemMode();
RtpemMode(int other_value);
RtpemMode(enum_type other_value);
RtpemMode(const RtpemMode& other_value);

RtpemMode& operator=(int other_value);
RtpemMode& operator=(enum_type other_value);
RtpemMode& operator=(const RtpemMode& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const RtpemMode& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const RtpemMode& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const RtpemMode& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const RtpemMode& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const RtpemMode& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const RtpemMode& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const RtpemMode& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RtpemMode_template : public Base_Template {
union {
RtpemMode::enum_type single_value;
struct {
unsigned int n_values;
RtpemMode_template *list_value;
} value_list;
struct {
RtpemMode_template* precondition;
RtpemMode_template* implied_template;
} implication_;
dynmatch_struct<RtpemMode>* dyn_match;
};

void copy_template(const RtpemMode_template& other_value);

public:
RtpemMode_template();
RtpemMode_template(template_sel other_value);
RtpemMode_template(int other_value);
RtpemMode_template(RtpemMode::enum_type other_value);
RtpemMode_template(const RtpemMode& other_value);
RtpemMode_template(const OPTIONAL<RtpemMode>& other_value);
RtpemMode_template(RtpemMode_template* p_precondition, RtpemMode_template* p_implied_template);
RtpemMode_template(Dynamic_Match_Interface<RtpemMode>* p_dyn_match);
RtpemMode_template(const RtpemMode_template& other_value);
~RtpemMode_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
RtpemMode_template& operator=(template_sel other_value);
RtpemMode_template& operator=(int other_value);
RtpemMode_template& operator=(RtpemMode::enum_type other_value);
RtpemMode_template& operator=(const RtpemMode& other_value);
RtpemMode_template& operator=(const OPTIONAL<RtpemMode>& other_value);
RtpemMode_template& operator=(const RtpemMode_template& other_value);

boolean match(RtpemMode::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const RtpemMode& other_value, boolean legacy = FALSE) const;
RtpemMode::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
RtpemMode_template& list_item(unsigned int list_index);
void log() const;
void log_match(const RtpemMode& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class RTPEM__bind_call {
CHARSTRING param_local__host;
INTEGER param_local__port;
public:
inline CHARSTRING& local__host() { return param_local__host; }
inline const CHARSTRING& local__host() const { return param_local__host; }
inline INTEGER& local__port() { return param_local__port; }
inline const INTEGER& local__port() const { return param_local__port; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RTPEM__bind_call_redirect {
CHARSTRING *ptr_local__host;
INTEGER *ptr_local__port;
public:
RTPEM__bind_call_redirect(CHARSTRING *par_local__host = NULL, INTEGER *par_local__port = NULL)
 : ptr_local__host(par_local__host), ptr_local__port(par_local__port) { }
virtual ~RTPEM__bind_call_redirect() { }
virtual void set_parameters(const RTPEM__bind_call& call_par) const;
};

class RTPEM__bind_reply {
INTEGER param_local__port;
public:
inline INTEGER& local__port() { return param_local__port; }
inline const INTEGER& local__port() const { return param_local__port; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RTPEM__bind_reply_redirect {
INTEGER *ptr_local__port;
public:
RTPEM__bind_reply_redirect(INTEGER *par_local__port = NULL)
 : ptr_local__port(par_local__port) { }
virtual ~RTPEM__bind_reply_redirect() { }
virtual void set_parameters(const RTPEM__bind_reply& reply_par) const;
};

class RTPEM__bind_template {
CHARSTRING_template param_local__host;
INTEGER_template param_local__port;
public:
RTPEM__bind_template();
inline CHARSTRING_template& local__host() { return param_local__host; }
inline const CHARSTRING_template& local__host() const { return param_local__host; }
inline INTEGER_template& local__port() { return param_local__port; }
inline const INTEGER_template& local__port() const { return param_local__port; }
RTPEM__bind_call create_call() const;
RTPEM__bind_reply create_reply() const;
boolean match_call(const RTPEM__bind_call& match_value, boolean legacy = FALSE) const;
boolean match_reply(const RTPEM__bind_reply& match_value, boolean legacy = FALSE) const;
void log() const;
void log_match_call(const RTPEM__bind_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RTPEM__bind_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RTPEM__connect_call {
CHARSTRING param_remote__host;
INTEGER param_remote__port;
public:
inline CHARSTRING& remote__host() { return param_remote__host; }
inline const CHARSTRING& remote__host() const { return param_remote__host; }
inline INTEGER& remote__port() { return param_remote__port; }
inline const INTEGER& remote__port() const { return param_remote__port; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RTPEM__connect_call_redirect {
CHARSTRING *ptr_remote__host;
INTEGER *ptr_remote__port;
public:
RTPEM__connect_call_redirect(CHARSTRING *par_remote__host = NULL, INTEGER *par_remote__port = NULL)
 : ptr_remote__host(par_remote__host), ptr_remote__port(par_remote__port) { }
virtual ~RTPEM__connect_call_redirect() { }
virtual void set_parameters(const RTPEM__connect_call& call_par) const;
};

class RTPEM__connect_reply {
public:
inline void encode_text(Text_Buf&) const { }
inline void decode_text(Text_Buf&) { }
void log() const;
};

class RTPEM__connect_reply_redirect {
public:
inline void set_parameters(const RTPEM__connect_reply&) const {}
};

class RTPEM__connect_template {
CHARSTRING_template param_remote__host;
INTEGER_template param_remote__port;
public:
RTPEM__connect_template();
inline CHARSTRING_template& remote__host() { return param_remote__host; }
inline const CHARSTRING_template& remote__host() const { return param_remote__host; }
inline INTEGER_template& remote__port() { return param_remote__port; }
inline const INTEGER_template& remote__port() const { return param_remote__port; }
RTPEM__connect_call create_call() const;
inline RTPEM__connect_reply create_reply() const { return RTPEM__connect_reply(); }
boolean match_call(const RTPEM__connect_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const RTPEM__connect_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const RTPEM__connect_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RTPEM__connect_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RTPEM__mode_call {
RtpemMode param_mode;
public:
inline RtpemMode& mode() { return param_mode; }
inline const RtpemMode& mode() const { return param_mode; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RTPEM__mode_call_redirect {
RtpemMode *ptr_mode;
public:
RTPEM__mode_call_redirect(RtpemMode *par_mode = NULL)
 : ptr_mode(par_mode) { }
virtual ~RTPEM__mode_call_redirect() { }
virtual void set_parameters(const RTPEM__mode_call& call_par) const;
};

class RTPEM__mode_reply {
public:
inline void encode_text(Text_Buf&) const { }
inline void decode_text(Text_Buf&) { }
void log() const;
};

class RTPEM__mode_reply_redirect {
public:
inline void set_parameters(const RTPEM__mode_reply&) const {}
};

class RTPEM__mode_template {
RtpemMode_template param_mode;
public:
RTPEM__mode_template();
inline RtpemMode_template& mode() { return param_mode; }
inline const RtpemMode_template& mode() const { return param_mode; }
RTPEM__mode_call create_call() const;
inline RTPEM__mode_reply create_reply() const { return RTPEM__mode_reply(); }
boolean match_call(const RTPEM__mode_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const RTPEM__mode_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const RTPEM__mode_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RTPEM__mode_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RTPEM__configure_call {
RtpemConfig param_cfg;
public:
inline RtpemConfig& cfg() { return param_cfg; }
inline const RtpemConfig& cfg() const { return param_cfg; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RTPEM__configure_call_redirect {
RtpemConfig *ptr_cfg;
public:
RTPEM__configure_call_redirect(RtpemConfig *par_cfg = NULL)
 : ptr_cfg(par_cfg) { }
virtual ~RTPEM__configure_call_redirect() { }
virtual void set_parameters(const RTPEM__configure_call& call_par) const;
};

class RTPEM__configure_reply {
public:
inline void encode_text(Text_Buf&) const { }
inline void decode_text(Text_Buf&) { }
void log() const;
};

class RTPEM__configure_reply_redirect {
public:
inline void set_parameters(const RTPEM__configure_reply&) const {}
};

class RTPEM__configure_template {
RtpemConfig_template param_cfg;
public:
RTPEM__configure_template();
inline RtpemConfig_template& cfg() { return param_cfg; }
inline const RtpemConfig_template& cfg() const { return param_cfg; }
RTPEM__configure_call create_call() const;
inline RTPEM__configure_reply create_reply() const { return RTPEM__configure_reply(); }
boolean match_call(const RTPEM__configure_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const RTPEM__configure_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const RTPEM__configure_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RTPEM__configure_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RTPEM__stats__get_call {
BOOLEAN param_rtcp;
public:
inline BOOLEAN& rtcp() { return param_rtcp; }
inline const BOOLEAN& rtcp() const { return param_rtcp; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RTPEM__stats__get_call_redirect {
BOOLEAN *ptr_rtcp;
public:
RTPEM__stats__get_call_redirect(BOOLEAN *par_rtcp = NULL)
 : ptr_rtcp(par_rtcp) { }
virtual ~RTPEM__stats__get_call_redirect() { }
virtual void set_parameters(const RTPEM__stats__get_call& call_par) const;
};

class RTPEM__stats__get_reply {
RtpemStats param_stats;
public:
inline RtpemStats& stats() { return param_stats; }
inline const RtpemStats& stats() const { return param_stats; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RTPEM__stats__get_reply_redirect {
RtpemStats *ptr_stats;
public:
RTPEM__stats__get_reply_redirect(RtpemStats *par_stats = NULL)
 : ptr_stats(par_stats) { }
virtual ~RTPEM__stats__get_reply_redirect() { }
virtual void set_parameters(const RTPEM__stats__get_reply& reply_par) const;
};

class RTPEM__stats__get_template {
RtpemStats_template param_stats;
BOOLEAN_template param_rtcp;
public:
RTPEM__stats__get_template();
inline RtpemStats_template& stats() { return param_stats; }
inline const RtpemStats_template& stats() const { return param_stats; }
inline BOOLEAN_template& rtcp() { return param_rtcp; }
inline const BOOLEAN_template& rtcp() const { return param_rtcp; }
RTPEM__stats__get_call create_call() const;
RTPEM__stats__get_reply create_reply() const;
boolean match_call(const RTPEM__stats__get_call& match_value, boolean legacy = FALSE) const;
boolean match_reply(const RTPEM__stats__get_reply& match_value, boolean legacy = FALSE) const;
void log() const;
void log_match_call(const RTPEM__stats__get_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RTPEM__stats__get_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RTPEM__conn__refuse__expect_call {
BOOLEAN param_expect;
public:
inline BOOLEAN& expect() { return param_expect; }
inline const BOOLEAN& expect() const { return param_expect; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RTPEM__conn__refuse__expect_call_redirect {
BOOLEAN *ptr_expect;
public:
RTPEM__conn__refuse__expect_call_redirect(BOOLEAN *par_expect = NULL)
 : ptr_expect(par_expect) { }
virtual ~RTPEM__conn__refuse__expect_call_redirect() { }
virtual void set_parameters(const RTPEM__conn__refuse__expect_call& call_par) const;
};

class RTPEM__conn__refuse__expect_reply {
public:
inline void encode_text(Text_Buf&) const { }
inline void decode_text(Text_Buf&) { }
void log() const;
};

class RTPEM__conn__refuse__expect_reply_redirect {
public:
inline void set_parameters(const RTPEM__conn__refuse__expect_reply&) const {}
};

class RTPEM__conn__refuse__expect_template {
BOOLEAN_template param_expect;
public:
RTPEM__conn__refuse__expect_template();
inline BOOLEAN_template& expect() { return param_expect; }
inline const BOOLEAN_template& expect() const { return param_expect; }
RTPEM__conn__refuse__expect_call create_call() const;
inline RTPEM__conn__refuse__expect_reply create_reply() const { return RTPEM__conn__refuse__expect_reply(); }
boolean match_call(const RTPEM__conn__refuse__expect_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const RTPEM__conn__refuse__expect_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const RTPEM__conn__refuse__expect_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RTPEM__conn__refuse__expect_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RTPEM__conn__refuse__received_call {
public:
inline void encode_text(Text_Buf&) const { }
inline void decode_text(Text_Buf&) { }
void log() const;
};

class RTPEM__conn__refuse__received_call_redirect {
public:
inline void set_parameters(const RTPEM__conn__refuse__received_call&) const { }
};

class RTPEM__conn__refuse__received_reply {
BOOLEAN param_received;
public:
inline BOOLEAN& received() { return param_received; }
inline const BOOLEAN& received() const { return param_received; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RTPEM__conn__refuse__received_reply_redirect {
BOOLEAN *ptr_received;
public:
RTPEM__conn__refuse__received_reply_redirect(BOOLEAN *par_received = NULL)
 : ptr_received(par_received) { }
virtual ~RTPEM__conn__refuse__received_reply_redirect() { }
virtual void set_parameters(const RTPEM__conn__refuse__received_reply& reply_par) const;
};

class RTPEM__conn__refuse__received_template {
BOOLEAN_template param_received;
public:
RTPEM__conn__refuse__received_template();
inline BOOLEAN_template& received() { return param_received; }
inline const BOOLEAN_template& received() const { return param_received; }
inline RTPEM__conn__refuse__received_call create_call() const { return RTPEM__conn__refuse__received_call(); }
RTPEM__conn__refuse__received_reply create_reply() const;
inline boolean match_call(const RTPEM__conn__refuse__received_call&, boolean legacy = FALSE) const { return TRUE; }
boolean match_reply(const RTPEM__conn__refuse__received_reply& match_value, boolean legacy = FALSE) const;
void log() const;
void log_match_call(const RTPEM__conn__refuse__received_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RTPEM__conn__refuse__received_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RTPEM__CTRL__PT : public PORT {
enum proc_selection { CALL_0, CALL_1, CALL_2, CALL_3, CALL_4, CALL_5, CALL_6, REPLY_0, REPLY_1, REPLY_2, REPLY_3, REPLY_4, REPLY_5, REPLY_6 };
struct proc_queue_item {
proc_selection item_selection;
union {
RTPEM__bind_call *call_0;
RTPEM__connect_call *call_1;
RTPEM__mode_call *call_2;
RTPEM__configure_call *call_3;
RTPEM__stats__get_call *call_4;
RTPEM__conn__refuse__expect_call *call_5;
RTPEM__conn__refuse__received_call *call_6;
RTPEM__bind_reply *reply_0;
RTPEM__connect_reply *reply_1;
RTPEM__mode_reply *reply_2;
RTPEM__configure_reply *reply_3;
RTPEM__stats__get_reply *reply_4;
RTPEM__conn__refuse__expect_reply *reply_5;
RTPEM__conn__refuse__received_reply *reply_6;
};
component sender_component;
proc_queue_item *next_item;
} *proc_queue_head, *proc_queue_tail;
void append_to_proc_queue(proc_queue_item *new_item);
void remove_proc_queue_head();
protected:
void clear_queue();
public:
RTPEM__CTRL__PT(const char *par_port_name = NULL);
~RTPEM__CTRL__PT();
void call(const RTPEM__bind_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__bind_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__bind_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__connect_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__connect_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__connect_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__mode_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__mode_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__mode_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__configure_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__configure_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__configure_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__stats__get_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__stats__get_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__stats__get_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__conn__refuse__expect_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__conn__refuse__expect_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__conn__refuse__expect_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__conn__refuse__received_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__conn__refuse__received_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RTPEM__conn__refuse__received_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__bind_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__bind_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__bind_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__connect_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__connect_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__connect_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__mode_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__mode_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__mode_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__configure_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__configure_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__configure_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__stats__get_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__stats__get_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__stats__get_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__conn__refuse__expect_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__conn__refuse__expect_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__conn__refuse__expect_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__conn__refuse__received_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__conn__refuse__received_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RTPEM__conn__refuse__received_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
public:
alt_status getcall(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RTPEM__bind_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__bind_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RTPEM__bind_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__bind_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RTPEM__connect_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__connect_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RTPEM__connect_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__connect_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RTPEM__mode_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__mode_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RTPEM__mode_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__mode_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RTPEM__configure_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__configure_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RTPEM__configure_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__configure_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RTPEM__stats__get_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__stats__get_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RTPEM__stats__get_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__stats__get_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RTPEM__conn__refuse__expect_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__conn__refuse__expect_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RTPEM__conn__refuse__expect_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__conn__refuse__expect_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RTPEM__conn__refuse__received_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__conn__refuse__received_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RTPEM__conn__refuse__received_template& getcall_template, const COMPONENT_template& sender_template, const RTPEM__conn__refuse__received_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RTPEM__bind_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__bind_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RTPEM__bind_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__bind_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RTPEM__connect_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__connect_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RTPEM__connect_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__connect_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RTPEM__mode_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__mode_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RTPEM__mode_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__mode_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RTPEM__configure_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__configure_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RTPEM__configure_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__configure_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RTPEM__stats__get_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__stats__get_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RTPEM__stats__get_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__stats__get_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RTPEM__conn__refuse__expect_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__conn__refuse__expect_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RTPEM__conn__refuse__expect_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__conn__refuse__expect_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RTPEM__conn__refuse__received_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__conn__refuse__received_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RTPEM__conn__refuse__received_template& getreply_template, const COMPONENT_template& sender_template, const RTPEM__conn__refuse__received_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_call(const RTPEM__bind_call& incoming_par, component sender_component);
void incoming_call(const RTPEM__connect_call& incoming_par, component sender_component);
void incoming_call(const RTPEM__mode_call& incoming_par, component sender_component);
void incoming_call(const RTPEM__configure_call& incoming_par, component sender_component);
void incoming_call(const RTPEM__stats__get_call& incoming_par, component sender_component);
void incoming_call(const RTPEM__conn__refuse__expect_call& incoming_par, component sender_component);
void incoming_call(const RTPEM__conn__refuse__received_call& incoming_par, component sender_component);
void incoming_reply(const RTPEM__bind_reply& incoming_par, component sender_component);
void incoming_reply(const RTPEM__connect_reply& incoming_par, component sender_component);
void incoming_reply(const RTPEM__mode_reply& incoming_par, component sender_component);
void incoming_reply(const RTPEM__configure_reply& incoming_par, component sender_component);
void incoming_reply(const RTPEM__stats__get_reply& incoming_par, component sender_component);
void incoming_reply(const RTPEM__conn__refuse__expect_reply& incoming_par, component sender_component);
void incoming_reply(const RTPEM__conn__refuse__received_reply& incoming_par, component sender_component);
protected:
boolean process_call(const char *signature_name, Text_Buf& incoming_buf, component sender_component);
boolean process_reply(const char *signature_name, Text_Buf& incoming_buf, component sender_component);
};

class RTPEM__DATA__PT : public PORT {
enum msg_selection { MESSAGE_0, MESSAGE_1 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
RTP__Types::PDU__RTP *message_0;
RTP__Types::PDU__RTCP *message_1;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
RTPEM__DATA__PT(const char *par_port_name = NULL);
~RTPEM__DATA__PT();
void send(const RTP__Types::PDU__RTP& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTP& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTP& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTP_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTP_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTP_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTCP& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTCP& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTCP& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTCP_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTCP_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RTP__Types::PDU__RTCP_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
public:
alt_status receive(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const RTP__Types::PDU__RTP_template& value_template, RTP__Types::PDU__RTP *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const RTP__Types::PDU__RTP_template& value_template, RTP__Types::PDU__RTP *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const RTP__Types::PDU__RTP_template& value_template, RTP__Types::PDU__RTP *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const RTP__Types::PDU__RTCP_template& value_template, RTP__Types::PDU__RTCP *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const RTP__Types::PDU__RTCP_template& value_template, RTP__Types::PDU__RTCP *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const RTP__Types::PDU__RTCP_template& value_template, RTP__Types::PDU__RTCP *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const RTP__Types::PDU__RTP& incoming_par, component sender_component);
void incoming_message(const RTP__Types::PDU__RTCP& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};


/* Function prototypes */

extern boolean operator==(null_type null_value, const RtpemConfig_tx__payloads& other_value);
inline boolean operator!=(null_type null_value, const RtpemConfig_tx__payloads& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const RtpemConfig_rx__payloads& other_value);
inline boolean operator!=(null_type null_value, const RtpemConfig_rx__payloads& other_value) { return !(null_value == other_value); }
extern void f__rtpem__bind(RTPEM__CTRL__PT& pt, const CHARSTRING& local__host, INTEGER& local__port);
extern void f__rtpem__connect(RTPEM__CTRL__PT& pt, const CHARSTRING& remote__host, const INTEGER& remote__port);
extern void f__rtpem__mode(RTPEM__CTRL__PT& pt, const RtpemMode& mode);
extern void f__rtpem__configure(RTPEM__CTRL__PT& pt, const RtpemConfig& cfg);
extern RtpemStats f__rtpem__stats__get(RTPEM__CTRL__PT& pt, const BOOLEAN& rtcp);
extern BOOLEAN f__rtpem__stats__compare__value(const INTEGER& a, const INTEGER& b, const INTEGER& tolerance);
extern BOOLEAN f__rtpem__stats__compare(const RtpemStats& a, const RtpemStats& b, const INTEGER& tolerance);
extern void f__rtpem__stats__err__check(const RtpemStats& s);
extern void f__rtpem__conn__refuse__expect(RTPEM__CTRL__PT& pt);
extern void f__rtpem__conn__refuse__verify(RTPEM__CTRL__PT& pt);
extern RTP__Types::PDU__RTP_template ts__RTP(const BITSTRING& ssrc, const INTEGER& pt, const INTEGER& seq, const INTEGER& ts, const OCTETSTRING& payload, const BITSTRING& marker);
extern void f__tx__rtp(const OCTETSTRING& payload, const INTEGER& rtp__payload__type, const BITSTRING& marker);
extern void start_f__tx__rtp(const COMPONENT& component_reference, const OCTETSTRING& payload, const INTEGER& rtp__payload__type, const BITSTRING& marker);
extern void f__check__fixed__rx__payloads(const INTEGER& rtp__payload__type, const OCTETSTRING& rtp__data);
extern void start_f__check__fixed__rx__payloads(const COMPONENT& component_reference, const INTEGER& rtp__payload__type, const OCTETSTRING& rtp__data);
extern void f__main();
extern void start_f__main(const COMPONENT& component_reference);
extern void pre_init_module();
extern void post_init_module();
extern boolean init_comp_type(const char *component_type, boolean init_base_comps);
extern boolean init_system_port(const char* component_type, const char* port_name);
extern boolean start_ptc_function(const char *function_name, Text_Buf& function_arguments);

/* Global variable declarations */

extern const TTCN_Typedescriptor_t& RTP__Emulation__CT_descr_;
extern RTP__CodecPort::RTP__CODEC__PT RTP__Emulation__CT_component_RTP;
extern INTEGER RTP__Emulation__CT_component_g__rtp__conn__id;
extern RTP__CodecPort::RTP__CODEC__PT RTP__Emulation__CT_component_RTCP;
extern INTEGER RTP__Emulation__CT_component_g__rtcp__conn__id;
extern RTPEM__CTRL__PT RTP__Emulation__CT_component_CTRL;
extern RTPEM__DATA__PT RTP__Emulation__CT_component_DATA;
extern const XERdescriptor_t RtpemConfig_tx__samplerate__hz_xer_;
extern const TTCN_Typedescriptor_t RtpemConfig_tx__samplerate__hz_descr_;
extern const XERdescriptor_t RtpemConfig_tx__duration__ms_xer_;
extern const TTCN_Typedescriptor_t RtpemConfig_tx__duration__ms_descr_;
extern const XERdescriptor_t RtpemConfig_tx__ssrc_xer_;
extern const TTCN_OERdescriptor_t RtpemConfig_tx__ssrc_oer_;
extern const TTCN_Typedescriptor_t RtpemConfig_tx__ssrc_descr_;
extern UNIVERSAL_CHARSTRING RtpemConfig_tx__ssrc_default_coding;
extern const TTCN_Typedescriptor_t RtpemConfig_tx__payloads_descr_;
extern const XERdescriptor_t RtpemConfigPayload_payload__type_xer_;
extern const TTCN_OERdescriptor_t RtpemConfigPayload_payload__type_oer_;
extern const TTCN_Typedescriptor_t RtpemConfigPayload_payload__type_descr_;
extern UNIVERSAL_CHARSTRING RtpemConfigPayload_payload__type_default_coding;
extern const TTCN_Typedescriptor_t RtpemConfigPayload_descr_;
extern const XERdescriptor_t RtpemConfigPayload_fixed__payload_xer_;
extern const TTCN_OERdescriptor_t RtpemConfigPayload_fixed__payload_oer_;
extern const TTCN_Typedescriptor_t RtpemConfigPayload_fixed__payload_descr_;
extern const TTCN_Typedescriptor_t RtpemConfig_rx__payloads_descr_;
extern const XERdescriptor_t RtpemConfig_iuup__mode_xer_;
extern const TTCN_OERdescriptor_t RtpemConfig_iuup__mode_oer_;
extern const TTCN_Typedescriptor_t RtpemConfig_iuup__mode_descr_;
extern const TTCN_Typedescriptor_t RtpemConfig_descr_;
extern RtpemConfig RTP__Emulation__CT_component_g__cfg;
extern const XERdescriptor_t RtpemStats_num__pkts__tx_xer_;
extern const TTCN_Typedescriptor_t RtpemStats_num__pkts__tx_descr_;
extern const XERdescriptor_t RtpemStats_bytes__payload__tx_xer_;
extern const TTCN_Typedescriptor_t RtpemStats_bytes__payload__tx_descr_;
extern const XERdescriptor_t RtpemStats_num__pkts__rx_xer_;
extern const TTCN_Typedescriptor_t RtpemStats_num__pkts__rx_descr_;
extern const XERdescriptor_t RtpemStats_bytes__payload__rx_xer_;
extern const TTCN_Typedescriptor_t RtpemStats_bytes__payload__rx_descr_;
extern const XERdescriptor_t RtpemStats_num__pkts__rx__err__seq_xer_;
extern const TTCN_Typedescriptor_t RtpemStats_num__pkts__rx__err__seq_descr_;
extern const XERdescriptor_t RtpemStats_num__pkts__rx__err__ts_xer_;
extern const TTCN_Typedescriptor_t RtpemStats_num__pkts__rx__err__ts_descr_;
extern const XERdescriptor_t RtpemStats_num__pkts__rx__err__pt_xer_;
extern const TTCN_Typedescriptor_t RtpemStats_num__pkts__rx__err__pt_descr_;
extern const XERdescriptor_t RtpemStats_num__pkts__rx__err__disabled_xer_;
extern const TTCN_Typedescriptor_t RtpemStats_num__pkts__rx__err__disabled_descr_;
extern const XERdescriptor_t RtpemStats_num__pkts__rx__err__payload_xer_;
extern const TTCN_Typedescriptor_t RtpemStats_num__pkts__rx__err__payload_descr_;
extern const TTCN_Typedescriptor_t RtpemStats_descr_;
extern RtpemStats RTP__Emulation__CT_component_g__stats__rtp;
extern RtpemStats RTP__Emulation__CT_component_g__stats__rtcp;
extern CHARSTRING RTP__Emulation__CT_component_g__remote__host;
extern INTEGER RTP__Emulation__CT_component_g__remote__port;
extern CHARSTRING RTP__Emulation__CT_component_g__local__host;
extern INTEGER RTP__Emulation__CT_component_g__local__port;
extern BOOLEAN RTP__Emulation__CT_component_g__loopback;
extern BOOLEAN RTP__Emulation__CT_component_g__rx__enabled;
extern BOOLEAN RTP__Emulation__CT_component_g__tx__connected;
extern INTEGER RTP__Emulation__CT_component_g__tx__next__seq;
extern INTEGER RTP__Emulation__CT_component_g__tx__next__ts;
extern INTEGER RTP__Emulation__CT_component_g__rx__payload__type;
extern INTEGER RTP__Emulation__CT_component_g__rx__last__seq;
extern INTEGER RTP__Emulation__CT_component_g__rx__last__ts;
extern IuUP__Emulation::IuUP__Entity RTP__Emulation__CT_component_g__iuup__ent;
extern BOOLEAN RTP__Emulation__CT_component_g__conn__refuse__expect;
extern BOOLEAN RTP__Emulation__CT_component_g__conn__refuse__received;
extern const TTCN_Typedescriptor_t RtpemMode_descr_;
extern const RtpemStats& c__RtpemStatsReset;
extern RtpemStats const_c__RtpemStatsReset;
extern const RtpemConfig& c__RtpemDefaultCfg;
extern RtpemConfig const_c__RtpemDefaultCfg;
extern const BOOLEAN& f__rtpem__stats__get_rtcp_defval;
extern BOOLEAN const_f__rtpem__stats__get_rtcp_defval;
extern const INTEGER& f__rtpem__stats__compare__value_tolerance_defval;
extern INTEGER const_f__rtpem__stats__compare__value_tolerance_defval;
extern const INTEGER& f__rtpem__stats__compare_tolerance_defval;
extern INTEGER const_f__rtpem__stats__compare_tolerance_defval;
extern const BITSTRING& ts__RTP_marker_defval;
extern BITSTRING const_ts__RTP_marker_defval;
extern const BITSTRING& f__tx__rtp_marker_defval;
extern BITSTRING const_f__tx__rtp_marker_defval;
extern const BITSTRING bs_1,
bs_0;
extern const OCTETSTRING os_1,
os_0;
extern const CHARSTRING cs_0;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
