// 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 OSMUX__Emulation_HH
#define OSMUX__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 "OSMUX_CodecPort_CtrlFunct.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 OSMUX__Emulation_HH
#endif

namespace OSMUX__Emulation {

/* Forward declarations of classes */

class OsmuxemConfig;
class OsmuxemConfig_template;
class OsmuxemStats;
class OsmuxemStats_template;
class OsmuxRxHandle;
class OsmuxRxHandle_template;
class RxHandleTableRec;
class RxHandleTableRec_template;
class OsmuxTxHandle;
class OsmuxTxHandle_template;
class OsmuxemMode;
class OsmuxemMode_template;
class OsmuxEM__bind_call;
class OsmuxEM__bind_call_redirect;
class OsmuxEM__bind_reply;
class OsmuxEM__bind_reply_redirect;
class OsmuxEM__bind_template;
class OsmuxEM__connect_call;
class OsmuxEM__connect_call_redirect;
class OsmuxEM__connect_reply;
class OsmuxEM__connect_reply_redirect;
class OsmuxEM__connect_template;
class OsmuxEM__mode_call;
class OsmuxEM__mode_call_redirect;
class OsmuxEM__mode_reply;
class OsmuxEM__mode_reply_redirect;
class OsmuxEM__mode_template;
class OsmuxEM__configure_call;
class OsmuxEM__configure_call_redirect;
class OsmuxEM__configure_reply;
class OsmuxEM__configure_reply_redirect;
class OsmuxEM__configure_template;
class OsmuxEM__stats__get_call;
class OsmuxEM__stats__get_call_redirect;
class OsmuxEM__stats__get_reply;
class OsmuxEM__stats__get_reply_redirect;
class OsmuxEM__stats__get_template;
class OsmuxEM__register__rxhandle_call;
class OsmuxEM__register__rxhandle_call_redirect;
class OsmuxEM__register__rxhandle_reply;
class OsmuxEM__register__rxhandle_reply_redirect;
class OsmuxEM__register__rxhandle_template;
class OsmuxEM__register__txhandle_call;
class OsmuxEM__register__txhandle_call_redirect;
class OsmuxEM__register__txhandle_reply;
class OsmuxEM__register__txhandle_reply_redirect;
class OsmuxEM__register__txhandle_template;
class OsmuxEM__CTRL__PT;
class OsmuxEM__DATA__PT;

} /* end of namespace */

#ifndef OSMUX__Emulation_HH
#define OSMUX__Emulation_HH

namespace OSMUX__Emulation {

/* Type definitions */

typedef COMPONENT OSMUX__Emulation__CT;
typedef COMPONENT_template OSMUX__Emulation__CT_template;

/* Class definitions */

class OsmuxemConfig {
  INTEGER field_batch__size;
  INTEGER field_tx__duration__ms;
  OPTIONAL< OCTETSTRING > field_tx__fixed__payload;
  OPTIONAL< OCTETSTRING > field_rx__fixed__payload;
public:
  OsmuxemConfig();
  OsmuxemConfig(const INTEGER& par_batch__size,
    const INTEGER& par_tx__duration__ms,
    const OPTIONAL< OCTETSTRING >& par_tx__fixed__payload,
    const OPTIONAL< OCTETSTRING >& par_rx__fixed__payload);
  OsmuxemConfig(const OsmuxemConfig& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  OsmuxemConfig& operator=(const OsmuxemConfig& other_value);
  boolean operator==(const OsmuxemConfig& other_value) const;
  inline boolean operator!=(const OsmuxemConfig& 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& batch__size()
    {return field_batch__size;}
  inline const INTEGER& batch__size() const
    {return field_batch__size;}
  inline INTEGER& tx__duration__ms()
    {return field_tx__duration__ms;}
  inline const INTEGER& tx__duration__ms() const
    {return field_tx__duration__ms;}
  inline OPTIONAL< OCTETSTRING >& tx__fixed__payload()
    {return field_tx__fixed__payload;}
  inline const OPTIONAL< OCTETSTRING >& tx__fixed__payload() const
    {return field_tx__fixed__payload;}
  inline OPTIONAL< OCTETSTRING >& rx__fixed__payload()
    {return field_rx__fixed__payload;}
  inline const OPTIONAL< OCTETSTRING >& rx__fixed__payload() const
    {return field_rx__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 OsmuxemConfig_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
OsmuxemConfig_template *list_value;
} value_list;
struct {
OsmuxemConfig_template* precondition;
OsmuxemConfig_template* implied_template;
} implication_;
dynmatch_struct<OsmuxemConfig>* dyn_match;
};

void set_specific();
void copy_value(const OsmuxemConfig& other_value);
void copy_template(const OsmuxemConfig_template& other_value);

public:
OsmuxemConfig_template();
OsmuxemConfig_template(template_sel other_value);
OsmuxemConfig_template(const OsmuxemConfig& other_value);
OsmuxemConfig_template(const OPTIONAL<OsmuxemConfig>& other_value);
OsmuxemConfig_template(OsmuxemConfig_template* p_precondition, OsmuxemConfig_template* p_implied_template);
OsmuxemConfig_template(Dynamic_Match_Interface<OsmuxemConfig>* p_dyn_match);
OsmuxemConfig_template(const OsmuxemConfig_template& other_value);
~OsmuxemConfig_template();
OsmuxemConfig_template& operator=(template_sel other_value);
OsmuxemConfig_template& operator=(const OsmuxemConfig& other_value);
OsmuxemConfig_template& operator=(const OPTIONAL<OsmuxemConfig>& other_value);
OsmuxemConfig_template& operator=(const OsmuxemConfig_template& other_value);
boolean match(const OsmuxemConfig& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
OsmuxemConfig valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
OsmuxemConfig_template& list_item(unsigned int list_index) const;
INTEGER_template& batch__size();
const INTEGER_template& batch__size() const;
INTEGER_template& tx__duration__ms();
const INTEGER_template& tx__duration__ms() const;
OCTETSTRING_template& tx__fixed__payload();
const OCTETSTRING_template& tx__fixed__payload() const;
OCTETSTRING_template& rx__fixed__payload();
const OCTETSTRING_template& rx__fixed__payload() const;
int size_of() const;
void log() const;
void log_match(const OsmuxemConfig& 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 OsmuxemStats {
  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__disabled;
  INTEGER field_num__pkts__rx__err__payload;
public:
  OsmuxemStats();
  OsmuxemStats(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__disabled,
    const INTEGER& par_num__pkts__rx__err__payload);
  OsmuxemStats(const OsmuxemStats& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  OsmuxemStats& operator=(const OsmuxemStats& other_value);
  boolean operator==(const OsmuxemStats& other_value) const;
  inline boolean operator!=(const OsmuxemStats& 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__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 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 OsmuxemStats_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
OsmuxemStats_template *list_value;
} value_list;
struct {
OsmuxemStats_template* precondition;
OsmuxemStats_template* implied_template;
} implication_;
dynmatch_struct<OsmuxemStats>* dyn_match;
};

void set_specific();
void copy_value(const OsmuxemStats& other_value);
void copy_template(const OsmuxemStats_template& other_value);

public:
OsmuxemStats_template();
OsmuxemStats_template(template_sel other_value);
OsmuxemStats_template(const OsmuxemStats& other_value);
OsmuxemStats_template(const OPTIONAL<OsmuxemStats>& other_value);
OsmuxemStats_template(OsmuxemStats_template* p_precondition, OsmuxemStats_template* p_implied_template);
OsmuxemStats_template(Dynamic_Match_Interface<OsmuxemStats>* p_dyn_match);
OsmuxemStats_template(const OsmuxemStats_template& other_value);
~OsmuxemStats_template();
OsmuxemStats_template& operator=(template_sel other_value);
OsmuxemStats_template& operator=(const OsmuxemStats& other_value);
OsmuxemStats_template& operator=(const OPTIONAL<OsmuxemStats>& other_value);
OsmuxemStats_template& operator=(const OsmuxemStats_template& other_value);
boolean match(const OsmuxemStats& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
OsmuxemStats valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
OsmuxemStats_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__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 OsmuxemStats& 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 OsmuxRxHandle {
  INTEGER field_cid;
  BOOLEAN field_first__seq__seen;
  INTEGER field_last__seq__ack;
public:
  OsmuxRxHandle();
  OsmuxRxHandle(const INTEGER& par_cid,
    const BOOLEAN& par_first__seq__seen,
    const INTEGER& par_last__seq__ack);
  OsmuxRxHandle(const OsmuxRxHandle& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  OsmuxRxHandle& operator=(const OsmuxRxHandle& other_value);
  boolean operator==(const OsmuxRxHandle& other_value) const;
  inline boolean operator!=(const OsmuxRxHandle& 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& cid()
    {return field_cid;}
  inline const INTEGER& cid() const
    {return field_cid;}
  inline BOOLEAN& first__seq__seen()
    {return field_first__seq__seen;}
  inline const BOOLEAN& first__seq__seen() const
    {return field_first__seq__seen;}
  inline INTEGER& last__seq__ack()
    {return field_last__seq__ack;}
  inline const INTEGER& last__seq__ack() const
    {return field_last__seq__ack;}
  inline int size_of() const
    {return 3;}
  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 OsmuxRxHandle_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
OsmuxRxHandle_template *list_value;
} value_list;
struct {
OsmuxRxHandle_template* precondition;
OsmuxRxHandle_template* implied_template;
} implication_;
dynmatch_struct<OsmuxRxHandle>* dyn_match;
};

void set_specific();
void copy_value(const OsmuxRxHandle& other_value);
void copy_template(const OsmuxRxHandle_template& other_value);

public:
OsmuxRxHandle_template();
OsmuxRxHandle_template(template_sel other_value);
OsmuxRxHandle_template(const OsmuxRxHandle& other_value);
OsmuxRxHandle_template(const OPTIONAL<OsmuxRxHandle>& other_value);
OsmuxRxHandle_template(OsmuxRxHandle_template* p_precondition, OsmuxRxHandle_template* p_implied_template);
OsmuxRxHandle_template(Dynamic_Match_Interface<OsmuxRxHandle>* p_dyn_match);
OsmuxRxHandle_template(const OsmuxRxHandle_template& other_value);
~OsmuxRxHandle_template();
OsmuxRxHandle_template& operator=(template_sel other_value);
OsmuxRxHandle_template& operator=(const OsmuxRxHandle& other_value);
OsmuxRxHandle_template& operator=(const OPTIONAL<OsmuxRxHandle>& other_value);
OsmuxRxHandle_template& operator=(const OsmuxRxHandle_template& other_value);
boolean match(const OsmuxRxHandle& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
OsmuxRxHandle valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
OsmuxRxHandle_template& list_item(unsigned int list_index) const;
INTEGER_template& cid();
const INTEGER_template& cid() const;
BOOLEAN_template& first__seq__seen();
const BOOLEAN_template& first__seq__seen() const;
INTEGER_template& last__seq__ack();
const INTEGER_template& last__seq__ack() const;
int size_of() const;
void log() const;
void log_match(const OsmuxRxHandle& 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 RxHandleTableRec {
  INTEGER field_cid;
  OsmuxRxHandle field_vc__conn;
public:
  RxHandleTableRec();
  RxHandleTableRec(const INTEGER& par_cid,
    const OsmuxRxHandle& par_vc__conn);
  RxHandleTableRec(const RxHandleTableRec& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RxHandleTableRec& operator=(const RxHandleTableRec& other_value);
  boolean operator==(const RxHandleTableRec& other_value) const;
  inline boolean operator!=(const RxHandleTableRec& 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& cid()
    {return field_cid;}
  inline const INTEGER& cid() const
    {return field_cid;}
  inline OsmuxRxHandle& vc__conn()
    {return field_vc__conn;}
  inline const OsmuxRxHandle& vc__conn() const
    {return field_vc__conn;}
  inline int size_of() const
    {return 2;}
  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 RxHandleTableRec_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RxHandleTableRec_template *list_value;
} value_list;
struct {
RxHandleTableRec_template* precondition;
RxHandleTableRec_template* implied_template;
} implication_;
dynmatch_struct<RxHandleTableRec>* dyn_match;
};

void set_specific();
void copy_value(const RxHandleTableRec& other_value);
void copy_template(const RxHandleTableRec_template& other_value);

public:
RxHandleTableRec_template();
RxHandleTableRec_template(template_sel other_value);
RxHandleTableRec_template(const RxHandleTableRec& other_value);
RxHandleTableRec_template(const OPTIONAL<RxHandleTableRec>& other_value);
RxHandleTableRec_template(RxHandleTableRec_template* p_precondition, RxHandleTableRec_template* p_implied_template);
RxHandleTableRec_template(Dynamic_Match_Interface<RxHandleTableRec>* p_dyn_match);
RxHandleTableRec_template(const RxHandleTableRec_template& other_value);
~RxHandleTableRec_template();
RxHandleTableRec_template& operator=(template_sel other_value);
RxHandleTableRec_template& operator=(const RxHandleTableRec& other_value);
RxHandleTableRec_template& operator=(const OPTIONAL<RxHandleTableRec>& other_value);
RxHandleTableRec_template& operator=(const RxHandleTableRec_template& other_value);
boolean match(const RxHandleTableRec& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RxHandleTableRec valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RxHandleTableRec_template& list_item(unsigned int list_index) const;
INTEGER_template& cid();
const INTEGER_template& cid() const;
OsmuxRxHandle_template& vc__conn();
const OsmuxRxHandle_template& vc__conn() const;
int size_of() const;
void log() const;
void log_match(const RxHandleTableRec& 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 OsmuxTxHandle {
  INTEGER field_ft;
  BITSTRING field_amr__f;
  BITSTRING field_amr__q;
  INTEGER field_seq;
  INTEGER field_cid;
  INTEGER field_amr__ft;
  INTEGER field_amr__cmr;
public:
  OsmuxTxHandle();
  OsmuxTxHandle(const INTEGER& par_ft,
    const BITSTRING& par_amr__f,
    const BITSTRING& par_amr__q,
    const INTEGER& par_seq,
    const INTEGER& par_cid,
    const INTEGER& par_amr__ft,
    const INTEGER& par_amr__cmr);
  OsmuxTxHandle(const OsmuxTxHandle& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  OsmuxTxHandle& operator=(const OsmuxTxHandle& other_value);
  boolean operator==(const OsmuxTxHandle& other_value) const;
  inline boolean operator!=(const OsmuxTxHandle& 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& ft()
    {return field_ft;}
  inline const INTEGER& ft() const
    {return field_ft;}
  inline BITSTRING& amr__f()
    {return field_amr__f;}
  inline const BITSTRING& amr__f() const
    {return field_amr__f;}
  inline BITSTRING& amr__q()
    {return field_amr__q;}
  inline const BITSTRING& amr__q() const
    {return field_amr__q;}
  inline INTEGER& seq()
    {return field_seq;}
  inline const INTEGER& seq() const
    {return field_seq;}
  inline INTEGER& cid()
    {return field_cid;}
  inline const INTEGER& cid() const
    {return field_cid;}
  inline INTEGER& amr__ft()
    {return field_amr__ft;}
  inline const INTEGER& amr__ft() const
    {return field_amr__ft;}
  inline INTEGER& amr__cmr()
    {return field_amr__cmr;}
  inline const INTEGER& amr__cmr() const
    {return field_amr__cmr;}
  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 OsmuxTxHandle_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
OsmuxTxHandle_template *list_value;
} value_list;
struct {
OsmuxTxHandle_template* precondition;
OsmuxTxHandle_template* implied_template;
} implication_;
dynmatch_struct<OsmuxTxHandle>* dyn_match;
};

void set_specific();
void copy_value(const OsmuxTxHandle& other_value);
void copy_template(const OsmuxTxHandle_template& other_value);

public:
OsmuxTxHandle_template();
OsmuxTxHandle_template(template_sel other_value);
OsmuxTxHandle_template(const OsmuxTxHandle& other_value);
OsmuxTxHandle_template(const OPTIONAL<OsmuxTxHandle>& other_value);
OsmuxTxHandle_template(OsmuxTxHandle_template* p_precondition, OsmuxTxHandle_template* p_implied_template);
OsmuxTxHandle_template(Dynamic_Match_Interface<OsmuxTxHandle>* p_dyn_match);
OsmuxTxHandle_template(const OsmuxTxHandle_template& other_value);
~OsmuxTxHandle_template();
OsmuxTxHandle_template& operator=(template_sel other_value);
OsmuxTxHandle_template& operator=(const OsmuxTxHandle& other_value);
OsmuxTxHandle_template& operator=(const OPTIONAL<OsmuxTxHandle>& other_value);
OsmuxTxHandle_template& operator=(const OsmuxTxHandle_template& other_value);
boolean match(const OsmuxTxHandle& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
OsmuxTxHandle valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
OsmuxTxHandle_template& list_item(unsigned int list_index) const;
INTEGER_template& ft();
const INTEGER_template& ft() const;
BITSTRING_template& amr__f();
const BITSTRING_template& amr__f() const;
BITSTRING_template& amr__q();
const BITSTRING_template& amr__q() const;
INTEGER_template& seq();
const INTEGER_template& seq() const;
INTEGER_template& cid();
const INTEGER_template& cid() const;
INTEGER_template& amr__ft();
const INTEGER_template& amr__ft() const;
INTEGER_template& amr__cmr();
const INTEGER_template& amr__cmr() const;
int size_of() const;
void log() const;
void log_match(const OsmuxTxHandle& 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 OsmuxemMode : public Base_Type { // enum
friend class OsmuxemMode_template;
public:
enum enum_type { OSMUXEM__MODE__NONE = 0, OSMUXEM__MODE__TXONLY = 1, OSMUXEM__MODE__RXONLY = 2, OSMUXEM__MODE__BIDIR = 3, UNKNOWN_VALUE = 4, UNBOUND_VALUE = 5 };
private:
enum_type enum_value;

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

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

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const OsmuxemMode& 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 OsmuxemMode& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const OsmuxemMode& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const OsmuxemMode& 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 OsmuxemMode& 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 OsmuxemMode& 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 OsmuxemMode& 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 OsmuxemMode_template : public Base_Template {
union {
OsmuxemMode::enum_type single_value;
struct {
unsigned int n_values;
OsmuxemMode_template *list_value;
} value_list;
struct {
OsmuxemMode_template* precondition;
OsmuxemMode_template* implied_template;
} implication_;
dynmatch_struct<OsmuxemMode>* dyn_match;
};

void copy_template(const OsmuxemMode_template& other_value);

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

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

boolean match(OsmuxemMode::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const OsmuxemMode& other_value, boolean legacy = FALSE) const;
OsmuxemMode::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
OsmuxemMode_template& list_item(unsigned int list_index);
void log() const;
void log_match(const OsmuxemMode& 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 OsmuxEM__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 OsmuxEM__bind_call_redirect {
CHARSTRING *ptr_local__host;
INTEGER *ptr_local__port;
public:
OsmuxEM__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 ~OsmuxEM__bind_call_redirect() { }
virtual void set_parameters(const OsmuxEM__bind_call& call_par) const;
};

class OsmuxEM__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 OsmuxEM__bind_reply_redirect {
INTEGER *ptr_local__port;
public:
OsmuxEM__bind_reply_redirect(INTEGER *par_local__port = NULL)
 : ptr_local__port(par_local__port) { }
virtual ~OsmuxEM__bind_reply_redirect() { }
virtual void set_parameters(const OsmuxEM__bind_reply& reply_par) const;
};

class OsmuxEM__bind_template {
CHARSTRING_template param_local__host;
INTEGER_template param_local__port;
public:
OsmuxEM__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; }
OsmuxEM__bind_call create_call() const;
OsmuxEM__bind_reply create_reply() const;
boolean match_call(const OsmuxEM__bind_call& match_value, boolean legacy = FALSE) const;
boolean match_reply(const OsmuxEM__bind_reply& match_value, boolean legacy = FALSE) const;
void log() const;
void log_match_call(const OsmuxEM__bind_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const OsmuxEM__bind_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class OsmuxEM__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 OsmuxEM__connect_call_redirect {
CHARSTRING *ptr_remote__host;
INTEGER *ptr_remote__port;
public:
OsmuxEM__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 ~OsmuxEM__connect_call_redirect() { }
virtual void set_parameters(const OsmuxEM__connect_call& call_par) const;
};

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

class OsmuxEM__connect_reply_redirect {
public:
inline void set_parameters(const OsmuxEM__connect_reply&) const {}
};

class OsmuxEM__connect_template {
CHARSTRING_template param_remote__host;
INTEGER_template param_remote__port;
public:
OsmuxEM__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; }
OsmuxEM__connect_call create_call() const;
inline OsmuxEM__connect_reply create_reply() const { return OsmuxEM__connect_reply(); }
boolean match_call(const OsmuxEM__connect_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const OsmuxEM__connect_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const OsmuxEM__connect_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const OsmuxEM__connect_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

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

class OsmuxEM__mode_call_redirect {
OsmuxemMode *ptr_mode;
public:
OsmuxEM__mode_call_redirect(OsmuxemMode *par_mode = NULL)
 : ptr_mode(par_mode) { }
virtual ~OsmuxEM__mode_call_redirect() { }
virtual void set_parameters(const OsmuxEM__mode_call& call_par) const;
};

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

class OsmuxEM__mode_reply_redirect {
public:
inline void set_parameters(const OsmuxEM__mode_reply&) const {}
};

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

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

class OsmuxEM__configure_call_redirect {
OsmuxemConfig *ptr_cfg;
public:
OsmuxEM__configure_call_redirect(OsmuxemConfig *par_cfg = NULL)
 : ptr_cfg(par_cfg) { }
virtual ~OsmuxEM__configure_call_redirect() { }
virtual void set_parameters(const OsmuxEM__configure_call& call_par) const;
};

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

class OsmuxEM__configure_reply_redirect {
public:
inline void set_parameters(const OsmuxEM__configure_reply&) const {}
};

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

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

class OsmuxEM__stats__get_call_redirect {
public:
inline void set_parameters(const OsmuxEM__stats__get_call&) const { }
};

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

class OsmuxEM__stats__get_reply_redirect {
OsmuxemStats *ptr_stats;
public:
OsmuxEM__stats__get_reply_redirect(OsmuxemStats *par_stats = NULL)
 : ptr_stats(par_stats) { }
virtual ~OsmuxEM__stats__get_reply_redirect() { }
virtual void set_parameters(const OsmuxEM__stats__get_reply& reply_par) const;
};

class OsmuxEM__stats__get_template {
OsmuxemStats_template param_stats;
public:
OsmuxEM__stats__get_template();
inline OsmuxemStats_template& stats() { return param_stats; }
inline const OsmuxemStats_template& stats() const { return param_stats; }
inline OsmuxEM__stats__get_call create_call() const { return OsmuxEM__stats__get_call(); }
OsmuxEM__stats__get_reply create_reply() const;
inline boolean match_call(const OsmuxEM__stats__get_call&, boolean legacy = FALSE) const { return TRUE; }
boolean match_reply(const OsmuxEM__stats__get_reply& match_value, boolean legacy = FALSE) const;
void log() const;
void log_match_call(const OsmuxEM__stats__get_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const OsmuxEM__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 OsmuxEM__register__rxhandle_call {
OsmuxRxHandle param_hdl;
public:
inline OsmuxRxHandle& hdl() { return param_hdl; }
inline const OsmuxRxHandle& hdl() const { return param_hdl; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class OsmuxEM__register__rxhandle_call_redirect {
OsmuxRxHandle *ptr_hdl;
public:
OsmuxEM__register__rxhandle_call_redirect(OsmuxRxHandle *par_hdl = NULL)
 : ptr_hdl(par_hdl) { }
virtual ~OsmuxEM__register__rxhandle_call_redirect() { }
virtual void set_parameters(const OsmuxEM__register__rxhandle_call& call_par) const;
};

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

class OsmuxEM__register__rxhandle_reply_redirect {
public:
inline void set_parameters(const OsmuxEM__register__rxhandle_reply&) const {}
};

class OsmuxEM__register__rxhandle_template {
OsmuxRxHandle_template param_hdl;
public:
OsmuxEM__register__rxhandle_template();
inline OsmuxRxHandle_template& hdl() { return param_hdl; }
inline const OsmuxRxHandle_template& hdl() const { return param_hdl; }
OsmuxEM__register__rxhandle_call create_call() const;
inline OsmuxEM__register__rxhandle_reply create_reply() const { return OsmuxEM__register__rxhandle_reply(); }
boolean match_call(const OsmuxEM__register__rxhandle_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const OsmuxEM__register__rxhandle_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const OsmuxEM__register__rxhandle_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const OsmuxEM__register__rxhandle_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class OsmuxEM__register__txhandle_call {
OsmuxTxHandle param_hdl;
public:
inline OsmuxTxHandle& hdl() { return param_hdl; }
inline const OsmuxTxHandle& hdl() const { return param_hdl; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class OsmuxEM__register__txhandle_call_redirect {
OsmuxTxHandle *ptr_hdl;
public:
OsmuxEM__register__txhandle_call_redirect(OsmuxTxHandle *par_hdl = NULL)
 : ptr_hdl(par_hdl) { }
virtual ~OsmuxEM__register__txhandle_call_redirect() { }
virtual void set_parameters(const OsmuxEM__register__txhandle_call& call_par) const;
};

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

class OsmuxEM__register__txhandle_reply_redirect {
public:
inline void set_parameters(const OsmuxEM__register__txhandle_reply&) const {}
};

class OsmuxEM__register__txhandle_template {
OsmuxTxHandle_template param_hdl;
public:
OsmuxEM__register__txhandle_template();
inline OsmuxTxHandle_template& hdl() { return param_hdl; }
inline const OsmuxTxHandle_template& hdl() const { return param_hdl; }
OsmuxEM__register__txhandle_call create_call() const;
inline OsmuxEM__register__txhandle_reply create_reply() const { return OsmuxEM__register__txhandle_reply(); }
boolean match_call(const OsmuxEM__register__txhandle_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const OsmuxEM__register__txhandle_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const OsmuxEM__register__txhandle_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const OsmuxEM__register__txhandle_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class OsmuxEM__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 {
OsmuxEM__bind_call *call_0;
OsmuxEM__connect_call *call_1;
OsmuxEM__mode_call *call_2;
OsmuxEM__configure_call *call_3;
OsmuxEM__stats__get_call *call_4;
OsmuxEM__register__rxhandle_call *call_5;
OsmuxEM__register__txhandle_call *call_6;
OsmuxEM__bind_reply *reply_0;
OsmuxEM__connect_reply *reply_1;
OsmuxEM__mode_reply *reply_2;
OsmuxEM__configure_reply *reply_3;
OsmuxEM__stats__get_reply *reply_4;
OsmuxEM__register__rxhandle_reply *reply_5;
OsmuxEM__register__txhandle_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:
OsmuxEM__CTRL__PT(const char *par_port_name = NULL);
~OsmuxEM__CTRL__PT();
void call(const OsmuxEM__bind_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__bind_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__bind_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__connect_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__connect_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__connect_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__mode_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__mode_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__mode_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__configure_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__configure_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__configure_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__stats__get_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__stats__get_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__stats__get_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__register__rxhandle_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__register__rxhandle_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__register__rxhandle_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__register__txhandle_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__register__txhandle_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const OsmuxEM__register__txhandle_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__bind_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__bind_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__bind_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__connect_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__connect_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__connect_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__mode_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__mode_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__mode_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__configure_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__configure_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__configure_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__stats__get_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__stats__get_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__stats__get_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__register__rxhandle_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__register__rxhandle_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__register__rxhandle_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__register__txhandle_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__register__txhandle_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const OsmuxEM__register__txhandle_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 OsmuxEM__bind_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__bind_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const OsmuxEM__bind_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__bind_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const OsmuxEM__connect_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__connect_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const OsmuxEM__connect_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__connect_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const OsmuxEM__mode_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__mode_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const OsmuxEM__mode_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__mode_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const OsmuxEM__configure_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__configure_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const OsmuxEM__configure_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__configure_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const OsmuxEM__stats__get_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__stats__get_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const OsmuxEM__stats__get_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__stats__get_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const OsmuxEM__register__rxhandle_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__register__rxhandle_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const OsmuxEM__register__rxhandle_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__register__rxhandle_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const OsmuxEM__register__txhandle_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__register__txhandle_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const OsmuxEM__register__txhandle_template& getcall_template, const COMPONENT_template& sender_template, const OsmuxEM__register__txhandle_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 OsmuxEM__bind_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__bind_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const OsmuxEM__bind_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__bind_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const OsmuxEM__connect_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__connect_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const OsmuxEM__connect_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__connect_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const OsmuxEM__mode_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__mode_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const OsmuxEM__mode_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__mode_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const OsmuxEM__configure_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__configure_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const OsmuxEM__configure_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__configure_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const OsmuxEM__stats__get_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__stats__get_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const OsmuxEM__stats__get_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__stats__get_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const OsmuxEM__register__rxhandle_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__register__rxhandle_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const OsmuxEM__register__rxhandle_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__register__rxhandle_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const OsmuxEM__register__txhandle_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__register__txhandle_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const OsmuxEM__register__txhandle_template& getreply_template, const COMPONENT_template& sender_template, const OsmuxEM__register__txhandle_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_call(const OsmuxEM__bind_call& incoming_par, component sender_component);
void incoming_call(const OsmuxEM__connect_call& incoming_par, component sender_component);
void incoming_call(const OsmuxEM__mode_call& incoming_par, component sender_component);
void incoming_call(const OsmuxEM__configure_call& incoming_par, component sender_component);
void incoming_call(const OsmuxEM__stats__get_call& incoming_par, component sender_component);
void incoming_call(const OsmuxEM__register__rxhandle_call& incoming_par, component sender_component);
void incoming_call(const OsmuxEM__register__txhandle_call& incoming_par, component sender_component);
void incoming_reply(const OsmuxEM__bind_reply& incoming_par, component sender_component);
void incoming_reply(const OsmuxEM__connect_reply& incoming_par, component sender_component);
void incoming_reply(const OsmuxEM__mode_reply& incoming_par, component sender_component);
void incoming_reply(const OsmuxEM__configure_reply& incoming_par, component sender_component);
void incoming_reply(const OsmuxEM__stats__get_reply& incoming_par, component sender_component);
void incoming_reply(const OsmuxEM__register__rxhandle_reply& incoming_par, component sender_component);
void incoming_reply(const OsmuxEM__register__txhandle_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 OsmuxEM__DATA__PT : public PORT {
enum msg_selection { MESSAGE_0 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
OSMUX__Types::OSMUX__PDU *message_0;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
OsmuxEM__DATA__PT(const char *par_port_name = NULL);
~OsmuxEM__DATA__PT();
void send(const OSMUX__Types::OSMUX__PDU& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const OSMUX__Types::OSMUX__PDU& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const OSMUX__Types::OSMUX__PDU& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const OSMUX__Types::OSMUX__PDU_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const OSMUX__Types::OSMUX__PDU_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const OSMUX__Types::OSMUX__PDU_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 OSMUX__Types::OSMUX__PDU_template& value_template, OSMUX__Types::OSMUX__PDU *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const OSMUX__Types::OSMUX__PDU_template& value_template, OSMUX__Types::OSMUX__PDU *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const OSMUX__Types::OSMUX__PDU_template& value_template, OSMUX__Types::OSMUX__PDU *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const OSMUX__Types::OSMUX__PDU& 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 OsmuxTxHandle_template t__TxHandleAMR590(const INTEGER& cid);
extern void f__osmuxem__bind(OsmuxEM__CTRL__PT& pt, const CHARSTRING& local__host, INTEGER& local__port);
extern void f__osmuxem__connect(OsmuxEM__CTRL__PT& pt, const CHARSTRING& remote__host, const INTEGER& remote__port);
extern void f__osmuxem__mode(OsmuxEM__CTRL__PT& pt, const OsmuxemMode& mode);
extern void f__osmuxem__configure(OsmuxEM__CTRL__PT& pt, const OsmuxemConfig& cfg);
extern OsmuxemStats f__osmuxem__stats__get(OsmuxEM__CTRL__PT& pt);
extern void f__osmuxem__register__rxhandle(OsmuxEM__CTRL__PT& pt, const OsmuxRxHandle& hdl);
extern void f__osmuxem__register__txhandle(OsmuxEM__CTRL__PT& pt, const OsmuxTxHandle& hdl);
extern BOOLEAN f__osmuxem__stats__compare__value(const INTEGER& a, const INTEGER& b, const INTEGER& tolerance);
extern BOOLEAN f__osmuxem__stats__compare(const OsmuxemStats& a, const OsmuxemStats& b, const INTEGER& tolerance);
extern void f__osmuxem__stats__err__check(const OsmuxemStats& s);
extern OSMUX__Types::PDU__Osmux__AMR_template ts__OsmuxAMR(const BITSTRING& marker, const INTEGER& ctr, const BITSTRING& amr__f, const BITSTRING& amr__q, const INTEGER& seq, const INTEGER& cid, const INTEGER& amr__ft, const INTEGER& amr__cmr, const OCTETSTRING& payload);
extern OsmuxRxHandle f__rxhandle__get__by__cid(const INTEGER& cid);
extern void start_f__rxhandle__get__by__cid(const COMPONENT& component_reference, const INTEGER& cid);
extern void f__rxhandle__cid__add(const OsmuxRxHandle& hdl);
extern void start_f__rxhandle__cid__add(const COMPONENT& component_reference, const OsmuxRxHandle& hdl);
extern void f__txhandle__cid__add(const OsmuxTxHandle& hdl);
extern void start_f__txhandle__cid__add(const COMPONENT& component_reference, const OsmuxTxHandle& hdl);
extern OCTETSTRING f__osmux__gen__expected__rx__rtp__payload(const INTEGER& amr__ft, const OCTETSTRING& tx__fixed__payload);
extern OCTETSTRING f__osmux__gen__payload(const INTEGER& ctr, const INTEGER& amr__ft);
extern void start_f__osmux__gen__payload(const COMPONENT& component_reference, const INTEGER& ctr, const INTEGER& amr__ft);
extern void f__tx__osmux(const INTEGER& i, const INTEGER& ctr, const OCTETSTRING& payload, const BITSTRING& marker);
extern void start_f__tx__osmux(const COMPONENT& component_reference, const INTEGER& i, const INTEGER& ctr, const OCTETSTRING& payload, const BITSTRING& marker);
extern void f__tx__osmux__all__cid(const BITSTRING& marker);
extern void start_f__tx__osmux__all__cid(const COMPONENT& component_reference, const BITSTRING& marker);
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& OSMUX__Emulation__CT_descr_;
extern OSMUX__CodecPort::OSMUX__CODEC__PT OSMUX__Emulation__CT_component_OSMUX;
extern INTEGER OSMUX__Emulation__CT_component_g__osmux__conn__id;
extern OsmuxEM__CTRL__PT OSMUX__Emulation__CT_component_CTRL;
extern OsmuxEM__DATA__PT OSMUX__Emulation__CT_component_DATA;
extern const XERdescriptor_t OsmuxemConfig_batch__size_xer_;
extern const TTCN_OERdescriptor_t OsmuxemConfig_batch__size_oer_;
extern const TTCN_Typedescriptor_t OsmuxemConfig_batch__size_descr_;
extern UNIVERSAL_CHARSTRING OsmuxemConfig_batch__size_default_coding;
extern const XERdescriptor_t OsmuxemConfig_tx__duration__ms_xer_;
extern const TTCN_Typedescriptor_t OsmuxemConfig_tx__duration__ms_descr_;
extern const TTCN_Typedescriptor_t OsmuxemConfig_descr_;
extern const XERdescriptor_t OsmuxemConfig_tx__fixed__payload_xer_;
extern const TTCN_OERdescriptor_t OsmuxemConfig_tx__fixed__payload_oer_;
extern const TTCN_Typedescriptor_t OsmuxemConfig_tx__fixed__payload_descr_;
extern const XERdescriptor_t OsmuxemConfig_rx__fixed__payload_xer_;
extern const TTCN_OERdescriptor_t OsmuxemConfig_rx__fixed__payload_oer_;
extern const TTCN_Typedescriptor_t OsmuxemConfig_rx__fixed__payload_descr_;
extern OsmuxemConfig OSMUX__Emulation__CT_component_g__cfg;
extern const XERdescriptor_t OsmuxemStats_num__pkts__tx_xer_;
extern const TTCN_Typedescriptor_t OsmuxemStats_num__pkts__tx_descr_;
extern const XERdescriptor_t OsmuxemStats_bytes__payload__tx_xer_;
extern const TTCN_Typedescriptor_t OsmuxemStats_bytes__payload__tx_descr_;
extern const XERdescriptor_t OsmuxemStats_num__pkts__rx_xer_;
extern const TTCN_Typedescriptor_t OsmuxemStats_num__pkts__rx_descr_;
extern const XERdescriptor_t OsmuxemStats_bytes__payload__rx_xer_;
extern const TTCN_Typedescriptor_t OsmuxemStats_bytes__payload__rx_descr_;
extern const XERdescriptor_t OsmuxemStats_num__pkts__rx__err__seq_xer_;
extern const TTCN_Typedescriptor_t OsmuxemStats_num__pkts__rx__err__seq_descr_;
extern const XERdescriptor_t OsmuxemStats_num__pkts__rx__err__disabled_xer_;
extern const TTCN_Typedescriptor_t OsmuxemStats_num__pkts__rx__err__disabled_descr_;
extern const XERdescriptor_t OsmuxemStats_num__pkts__rx__err__payload_xer_;
extern const TTCN_Typedescriptor_t OsmuxemStats_num__pkts__rx__err__payload_descr_;
extern const TTCN_Typedescriptor_t OsmuxemStats_descr_;
extern OsmuxemStats OSMUX__Emulation__CT_component_g__stat;
extern CHARSTRING OSMUX__Emulation__CT_component_g__remote__host;
extern INTEGER OSMUX__Emulation__CT_component_g__remote__port;
extern CHARSTRING OSMUX__Emulation__CT_component_g__local__host;
extern INTEGER OSMUX__Emulation__CT_component_g__local__port;
extern BOOLEAN OSMUX__Emulation__CT_component_g__rx__enabled;
extern BOOLEAN OSMUX__Emulation__CT_component_g__tx__connected;
extern INTEGER OSMUX__Emulation__CT_component_g__rx__payload__type;
extern INTEGER OSMUX__Emulation__CT_component_g__rx__last__seq;
extern INTEGER OSMUX__Emulation__CT_component_g__rx__last__ts;
extern const XERdescriptor_t RxHandleTableRec_cid_xer_;
extern const TTCN_OERdescriptor_t RxHandleTableRec_cid_oer_;
extern const TTCN_Typedescriptor_t RxHandleTableRec_cid_descr_;
extern UNIVERSAL_CHARSTRING RxHandleTableRec_cid_default_coding;
extern const XERdescriptor_t OsmuxRxHandle_cid_xer_;
extern const TTCN_OERdescriptor_t OsmuxRxHandle_cid_oer_;
extern const TTCN_Typedescriptor_t OsmuxRxHandle_cid_descr_;
extern UNIVERSAL_CHARSTRING OsmuxRxHandle_cid_default_coding;
extern const XERdescriptor_t OsmuxRxHandle_first__seq__seen_xer_;
extern const TTCN_OERdescriptor_t OsmuxRxHandle_first__seq__seen_oer_;
extern const TTCN_Typedescriptor_t OsmuxRxHandle_first__seq__seen_descr_;
extern const XERdescriptor_t OsmuxRxHandle_last__seq__ack_xer_;
extern const TTCN_OERdescriptor_t OsmuxRxHandle_last__seq__ack_oer_;
extern const TTCN_Typedescriptor_t OsmuxRxHandle_last__seq__ack_descr_;
extern UNIVERSAL_CHARSTRING OsmuxRxHandle_last__seq__ack_default_coding;
extern const TTCN_Typedescriptor_t OsmuxRxHandle_descr_;
extern const TTCN_Typedescriptor_t RxHandleTableRec_descr_;
extern VALUE_ARRAY<RxHandleTableRec, 16, 0> OSMUX__Emulation__CT_component_RxHandleTable;
extern const XERdescriptor_t OsmuxTxHandle_ft_xer_;
extern const TTCN_OERdescriptor_t OsmuxTxHandle_ft_oer_;
extern const TTCN_Typedescriptor_t OsmuxTxHandle_ft_descr_;
extern UNIVERSAL_CHARSTRING OsmuxTxHandle_ft_default_coding;
extern const XERdescriptor_t OsmuxTxHandle_amr__f_xer_;
extern const TTCN_OERdescriptor_t OsmuxTxHandle_amr__f_oer_;
extern const TTCN_Typedescriptor_t OsmuxTxHandle_amr__f_descr_;
extern UNIVERSAL_CHARSTRING OsmuxTxHandle_amr__f_default_coding;
extern const XERdescriptor_t OsmuxTxHandle_amr__q_xer_;
extern const TTCN_OERdescriptor_t OsmuxTxHandle_amr__q_oer_;
extern const TTCN_Typedescriptor_t OsmuxTxHandle_amr__q_descr_;
extern UNIVERSAL_CHARSTRING OsmuxTxHandle_amr__q_default_coding;
extern const XERdescriptor_t OsmuxTxHandle_seq_xer_;
extern const TTCN_OERdescriptor_t OsmuxTxHandle_seq_oer_;
extern const TTCN_Typedescriptor_t OsmuxTxHandle_seq_descr_;
extern UNIVERSAL_CHARSTRING OsmuxTxHandle_seq_default_coding;
extern const XERdescriptor_t OsmuxTxHandle_cid_xer_;
extern const TTCN_OERdescriptor_t OsmuxTxHandle_cid_oer_;
extern const TTCN_Typedescriptor_t OsmuxTxHandle_cid_descr_;
extern UNIVERSAL_CHARSTRING OsmuxTxHandle_cid_default_coding;
extern const XERdescriptor_t OsmuxTxHandle_amr__ft_xer_;
extern const TTCN_OERdescriptor_t OsmuxTxHandle_amr__ft_oer_;
extern const TTCN_Typedescriptor_t OsmuxTxHandle_amr__ft_descr_;
extern UNIVERSAL_CHARSTRING OsmuxTxHandle_amr__ft_default_coding;
extern const XERdescriptor_t OsmuxTxHandle_amr__cmr_xer_;
extern const TTCN_OERdescriptor_t OsmuxTxHandle_amr__cmr_oer_;
extern const TTCN_Typedescriptor_t OsmuxTxHandle_amr__cmr_descr_;
extern UNIVERSAL_CHARSTRING OsmuxTxHandle_amr__cmr_default_coding;
extern const TTCN_Typedescriptor_t OsmuxTxHandle_descr_;
extern VALUE_ARRAY<OsmuxTxHandle, 16, 0> OSMUX__Emulation__CT_component_TxHandleList;
extern const OsmuxRxHandle& c__OsmuxemDefaultRxHandle;
extern OsmuxRxHandle const_c__OsmuxemDefaultRxHandle;
extern const TTCN_Typedescriptor_t OsmuxemMode_descr_;
extern const OsmuxemStats& c__OsmuxemStatsReset;
extern OsmuxemStats const_c__OsmuxemStatsReset;
extern const OsmuxemConfig& c__OsmuxemDefaultCfg;
extern OsmuxemConfig const_c__OsmuxemDefaultCfg;
extern const INTEGER& f__osmuxem__stats__compare__value_tolerance_defval;
extern INTEGER const_f__osmuxem__stats__compare__value_tolerance_defval;
extern const INTEGER& f__osmuxem__stats__compare_tolerance_defval;
extern INTEGER const_f__osmuxem__stats__compare_tolerance_defval;
extern const BITSTRING& f__tx__osmux_marker_defval;
extern BITSTRING const_f__tx__osmux_marker_defval;
extern const BITSTRING& f__tx__osmux__all__cid_marker_defval;
extern BITSTRING const_f__tx__osmux__all__cid_marker_defval;
extern const BITSTRING bs_0,
bs_1;
extern const OCTETSTRING os_1,
os_0;
extern const CHARSTRING cs_8,
cs_7,
cs_6,
cs_0,
cs_3,
cs_4,
cs_5,
cs_9,
cs_2,
cs_1;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
