// 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 RSL__Emulation_HH
#define RSL__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 "IPA_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 RSL__Emulation_HH
#endif

namespace RSL__Emulation {

/* Forward declarations of classes */

class RSLDC__ChanRqd;
class RSLDC__ChanRqd_template;
class RSLEm__EventType;
class RSLEm__EventType_template;
class RSLEm__Event;
class RSLEm__Event_template;
class RSL__DCHAN__PT;
class RSL__CCHAN__PT;
class RSLEM__register_call;
class RSLEM__register_call_redirect;
class RSLEM__register_reply;
class RSLEM__register_reply_redirect;
class RSLEM__register_template;
class RSLEM__unregister_call;
class RSLEM__unregister_call_redirect;
class RSLEM__unregister_reply;
class RSLEM__unregister_reply_redirect;
class RSLEM__unregister_template;
class RSLEM__suspend_call;
class RSLEM__suspend_call_redirect;
class RSLEM__suspend_reply;
class RSLEM__suspend_reply_redirect;
class RSLEM__suspend_template;
class RSLEM__wait__queue_call;
class RSLEM__wait__queue_call_redirect;
class RSLEM__wait__queue_reply;
class RSLEM__wait__queue_reply_redirect;
class RSLEM__wait__queue_template;
class RSLEM__get__last__act_call;
class RSLEM__get__last__act_call_redirect;
class RSLEM__get__last__act_reply;
class RSLEM__get__last__act_reply_redirect;
class RSLEM__get__last__act_template;
class RSLEM__set__auto__chan__act__ack_call;
class RSLEM__set__auto__chan__act__ack_call_redirect;
class RSLEM__set__auto__chan__act__ack_reply;
class RSLEM__set__auto__chan__act__ack_reply_redirect;
class RSLEM__set__auto__chan__act__ack_template;
class RSLEM__PROC__PT;
class ConnectionData;
class ConnectionData_template;
class LastActData;
class LastActData_template;
class ASP__RSL__UDList;
class ASP__RSL__UDList_template;

} /* end of namespace */

#ifndef RSL__Emulation_HH
#define RSL__Emulation_HH

namespace RSL__Emulation {

/* Type definitions */

typedef COMPONENT RSL__DchanHdlr;
typedef COMPONENT_template RSL__DchanHdlr_template;
typedef COMPONENT RSL__Emulation__CT;
typedef COMPONENT_template RSL__Emulation__CT_template;

/* Class definitions */

class RSLDC__ChanRqd {
  OCTETSTRING field_ra;
  OPTIONAL< INTEGER > field_fn;
public:
  RSLDC__ChanRqd();
  RSLDC__ChanRqd(const OCTETSTRING& par_ra,
    const OPTIONAL< INTEGER >& par_fn);
  RSLDC__ChanRqd(const RSLDC__ChanRqd& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RSLDC__ChanRqd& operator=(const RSLDC__ChanRqd& other_value);
  boolean operator==(const RSLDC__ChanRqd& other_value) const;
  inline boolean operator!=(const RSLDC__ChanRqd& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OCTETSTRING& ra()
    {return field_ra;}
  inline const OCTETSTRING& ra() const
    {return field_ra;}
  inline OPTIONAL< INTEGER >& fn()
    {return field_fn;}
  inline const OPTIONAL< INTEGER >& fn() const
    {return field_fn;}
  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 RSLDC__ChanRqd_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RSLDC__ChanRqd_template *list_value;
} value_list;
struct {
RSLDC__ChanRqd_template* precondition;
RSLDC__ChanRqd_template* implied_template;
} implication_;
dynmatch_struct<RSLDC__ChanRqd>* dyn_match;
};

void set_specific();
void copy_value(const RSLDC__ChanRqd& other_value);
void copy_template(const RSLDC__ChanRqd_template& other_value);

public:
RSLDC__ChanRqd_template();
RSLDC__ChanRqd_template(template_sel other_value);
RSLDC__ChanRqd_template(const RSLDC__ChanRqd& other_value);
RSLDC__ChanRqd_template(const OPTIONAL<RSLDC__ChanRqd>& other_value);
RSLDC__ChanRqd_template(RSLDC__ChanRqd_template* p_precondition, RSLDC__ChanRqd_template* p_implied_template);
RSLDC__ChanRqd_template(Dynamic_Match_Interface<RSLDC__ChanRqd>* p_dyn_match);
RSLDC__ChanRqd_template(const RSLDC__ChanRqd_template& other_value);
~RSLDC__ChanRqd_template();
RSLDC__ChanRqd_template& operator=(template_sel other_value);
RSLDC__ChanRqd_template& operator=(const RSLDC__ChanRqd& other_value);
RSLDC__ChanRqd_template& operator=(const OPTIONAL<RSLDC__ChanRqd>& other_value);
RSLDC__ChanRqd_template& operator=(const RSLDC__ChanRqd_template& other_value);
boolean match(const RSLDC__ChanRqd& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RSLDC__ChanRqd valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RSLDC__ChanRqd_template& list_item(unsigned int list_index) const;
OCTETSTRING_template& ra();
const OCTETSTRING_template& ra() const;
INTEGER_template& fn();
const INTEGER_template& fn() const;
int size_of() const;
void log() const;
void log_match(const RSLDC__ChanRqd& 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 RSLEm__EventType : public Base_Type { // enum
friend class RSLEm__EventType_template;
public:
enum enum_type { RSLEM__EV__TRX__UP = 0, RSLEM__EV__TRX__DOWN = 1, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

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

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

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

void copy_template(const RSLEm__EventType_template& other_value);

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

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

boolean match(RSLEm__EventType::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const RSLEm__EventType& other_value, boolean legacy = FALSE) const;
RSLEm__EventType::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
RSLEm__EventType_template& list_item(unsigned int list_index);
void log() const;
void log_match(const RSLEm__EventType& 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 RSLEm__Event {
  RSLEm__EventType field_ev__type;
  IPA__Types::IpaStreamId field_sid;
public:
  RSLEm__Event();
  RSLEm__Event(const RSLEm__EventType& par_ev__type,
    const IPA__Types::IpaStreamId& par_sid);
  RSLEm__Event(const RSLEm__Event& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RSLEm__Event& operator=(const RSLEm__Event& other_value);
  boolean operator==(const RSLEm__Event& other_value) const;
  inline boolean operator!=(const RSLEm__Event& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline RSLEm__EventType& ev__type()
    {return field_ev__type;}
  inline const RSLEm__EventType& ev__type() const
    {return field_ev__type;}
  inline IPA__Types::IpaStreamId& sid()
    {return field_sid;}
  inline const IPA__Types::IpaStreamId& sid() const
    {return field_sid;}
  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 RSLEm__Event_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RSLEm__Event_template *list_value;
} value_list;
struct {
RSLEm__Event_template* precondition;
RSLEm__Event_template* implied_template;
} implication_;
dynmatch_struct<RSLEm__Event>* dyn_match;
};

void set_specific();
void copy_value(const RSLEm__Event& other_value);
void copy_template(const RSLEm__Event_template& other_value);

public:
RSLEm__Event_template();
RSLEm__Event_template(template_sel other_value);
RSLEm__Event_template(const RSLEm__Event& other_value);
RSLEm__Event_template(const OPTIONAL<RSLEm__Event>& other_value);
RSLEm__Event_template(RSLEm__Event_template* p_precondition, RSLEm__Event_template* p_implied_template);
RSLEm__Event_template(Dynamic_Match_Interface<RSLEm__Event>* p_dyn_match);
RSLEm__Event_template(const RSLEm__Event_template& other_value);
~RSLEm__Event_template();
RSLEm__Event_template& operator=(template_sel other_value);
RSLEm__Event_template& operator=(const RSLEm__Event& other_value);
RSLEm__Event_template& operator=(const OPTIONAL<RSLEm__Event>& other_value);
RSLEm__Event_template& operator=(const RSLEm__Event_template& other_value);
boolean match(const RSLEm__Event& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RSLEm__Event valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RSLEm__Event_template& list_item(unsigned int list_index) const;
RSLEm__EventType_template& ev__type();
const RSLEm__EventType_template& ev__type() const;
IPA__Types::IpaStreamId_template& sid();
const IPA__Types::IpaStreamId_template& sid() const;
int size_of() const;
void log() const;
void log_match(const RSLEm__Event& 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 RSL__DCHAN__PT : public PORT {
enum msg_selection { MESSAGE_0, MESSAGE_1, MESSAGE_2 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
RSLDC__ChanRqd *message_0;
RSL__Types::RSL__Message *message_1;
IPA__Emulation::ASP__RSL__Unitdata *message_2;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
RSL__DCHAN__PT(const char *par_port_name = NULL);
~RSL__DCHAN__PT();
void send(const RSLDC__ChanRqd& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RSLDC__ChanRqd& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RSLDC__ChanRqd& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RSLDC__ChanRqd_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RSLDC__ChanRqd_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RSLDC__ChanRqd_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RSL__Types::RSL__Message& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RSL__Types::RSL__Message& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RSL__Types::RSL__Message& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RSL__Types::RSL__Message_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RSL__Types::RSL__Message_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RSL__Types::RSL__Message_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata_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 RSLDC__ChanRqd_template& value_template, RSLDC__ChanRqd *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const RSLDC__ChanRqd_template& value_template, RSLDC__ChanRqd *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const RSLDC__ChanRqd_template& value_template, RSLDC__ChanRqd *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const RSL__Types::RSL__Message_template& value_template, RSL__Types::RSL__Message *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const RSL__Types::RSL__Message_template& value_template, RSL__Types::RSL__Message *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const RSL__Types::RSL__Message_template& value_template, RSL__Types::RSL__Message *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const IPA__Emulation::ASP__RSL__Unitdata_template& value_template, IPA__Emulation::ASP__RSL__Unitdata *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const IPA__Emulation::ASP__RSL__Unitdata_template& value_template, IPA__Emulation::ASP__RSL__Unitdata *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const IPA__Emulation::ASP__RSL__Unitdata_template& value_template, IPA__Emulation::ASP__RSL__Unitdata *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const RSLDC__ChanRqd& incoming_par, component sender_component);
void incoming_message(const RSL__Types::RSL__Message& incoming_par, component sender_component);
void incoming_message(const IPA__Emulation::ASP__RSL__Unitdata& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class RSL__CCHAN__PT : public PORT {
enum msg_selection { MESSAGE_0, MESSAGE_1 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
IPA__Emulation::ASP__RSL__Unitdata *message_0;
RSLEm__Event *message_1;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
RSL__CCHAN__PT(const char *par_port_name = NULL);
~RSL__CCHAN__PT();
void send(const IPA__Emulation::ASP__RSL__Unitdata& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const IPA__Emulation::ASP__RSL__Unitdata_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RSLEm__Event& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RSLEm__Event& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RSLEm__Event& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RSLEm__Event_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RSLEm__Event_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RSLEm__Event_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 IPA__Emulation::ASP__RSL__Unitdata_template& value_template, IPA__Emulation::ASP__RSL__Unitdata *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const IPA__Emulation::ASP__RSL__Unitdata_template& value_template, IPA__Emulation::ASP__RSL__Unitdata *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const IPA__Emulation::ASP__RSL__Unitdata_template& value_template, IPA__Emulation::ASP__RSL__Unitdata *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const RSLEm__Event_template& value_template, RSLEm__Event *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const RSLEm__Event_template& value_template, RSLEm__Event *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const RSLEm__Event_template& value_template, RSLEm__Event *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const IPA__Emulation::ASP__RSL__Unitdata& incoming_par, component sender_component);
void incoming_message(const RSLEm__Event& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class RSLEM__register_call {
INTEGER param_trx__nr;
GSM__Types::RslChannelNr param_chan__nr;
COMPONENT param_hdlr;
public:
inline INTEGER& trx__nr() { return param_trx__nr; }
inline const INTEGER& trx__nr() const { return param_trx__nr; }
inline GSM__Types::RslChannelNr& chan__nr() { return param_chan__nr; }
inline const GSM__Types::RslChannelNr& chan__nr() const { return param_chan__nr; }
inline COMPONENT& hdlr() { return param_hdlr; }
inline const COMPONENT& hdlr() const { return param_hdlr; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RSLEM__register_call_redirect {
INTEGER *ptr_trx__nr;
GSM__Types::RslChannelNr *ptr_chan__nr;
COMPONENT *ptr_hdlr;
public:
RSLEM__register_call_redirect(INTEGER *par_trx__nr = NULL, GSM__Types::RslChannelNr *par_chan__nr = NULL, COMPONENT *par_hdlr = NULL)
 : ptr_trx__nr(par_trx__nr), ptr_chan__nr(par_chan__nr), ptr_hdlr(par_hdlr) { }
virtual ~RSLEM__register_call_redirect() { }
virtual void set_parameters(const RSLEM__register_call& call_par) const;
};

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

class RSLEM__register_reply_redirect {
public:
inline void set_parameters(const RSLEM__register_reply&) const {}
};

class RSLEM__register_template {
INTEGER_template param_trx__nr;
GSM__Types::RslChannelNr_template param_chan__nr;
COMPONENT_template param_hdlr;
public:
RSLEM__register_template();
inline INTEGER_template& trx__nr() { return param_trx__nr; }
inline const INTEGER_template& trx__nr() const { return param_trx__nr; }
inline GSM__Types::RslChannelNr_template& chan__nr() { return param_chan__nr; }
inline const GSM__Types::RslChannelNr_template& chan__nr() const { return param_chan__nr; }
inline COMPONENT_template& hdlr() { return param_hdlr; }
inline const COMPONENT_template& hdlr() const { return param_hdlr; }
RSLEM__register_call create_call() const;
inline RSLEM__register_reply create_reply() const { return RSLEM__register_reply(); }
boolean match_call(const RSLEM__register_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const RSLEM__register_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const RSLEM__register_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RSLEM__register_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RSLEM__unregister_call {
INTEGER param_trx__nr;
GSM__Types::RslChannelNr param_chan__nr;
COMPONENT param_hdlr;
public:
inline INTEGER& trx__nr() { return param_trx__nr; }
inline const INTEGER& trx__nr() const { return param_trx__nr; }
inline GSM__Types::RslChannelNr& chan__nr() { return param_chan__nr; }
inline const GSM__Types::RslChannelNr& chan__nr() const { return param_chan__nr; }
inline COMPONENT& hdlr() { return param_hdlr; }
inline const COMPONENT& hdlr() const { return param_hdlr; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RSLEM__unregister_call_redirect {
INTEGER *ptr_trx__nr;
GSM__Types::RslChannelNr *ptr_chan__nr;
COMPONENT *ptr_hdlr;
public:
RSLEM__unregister_call_redirect(INTEGER *par_trx__nr = NULL, GSM__Types::RslChannelNr *par_chan__nr = NULL, COMPONENT *par_hdlr = NULL)
 : ptr_trx__nr(par_trx__nr), ptr_chan__nr(par_chan__nr), ptr_hdlr(par_hdlr) { }
virtual ~RSLEM__unregister_call_redirect() { }
virtual void set_parameters(const RSLEM__unregister_call& call_par) const;
};

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

class RSLEM__unregister_reply_redirect {
public:
inline void set_parameters(const RSLEM__unregister_reply&) const {}
};

class RSLEM__unregister_template {
INTEGER_template param_trx__nr;
GSM__Types::RslChannelNr_template param_chan__nr;
COMPONENT_template param_hdlr;
public:
RSLEM__unregister_template();
inline INTEGER_template& trx__nr() { return param_trx__nr; }
inline const INTEGER_template& trx__nr() const { return param_trx__nr; }
inline GSM__Types::RslChannelNr_template& chan__nr() { return param_chan__nr; }
inline const GSM__Types::RslChannelNr_template& chan__nr() const { return param_chan__nr; }
inline COMPONENT_template& hdlr() { return param_hdlr; }
inline const COMPONENT_template& hdlr() const { return param_hdlr; }
RSLEM__unregister_call create_call() const;
inline RSLEM__unregister_reply create_reply() const { return RSLEM__unregister_reply(); }
boolean match_call(const RSLEM__unregister_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const RSLEM__unregister_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const RSLEM__unregister_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RSLEM__unregister_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RSLEM__suspend_call {
BOOLEAN param_suspend;
public:
inline BOOLEAN& suspend() { return param_suspend; }
inline const BOOLEAN& suspend() const { return param_suspend; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RSLEM__suspend_call_redirect {
BOOLEAN *ptr_suspend;
public:
RSLEM__suspend_call_redirect(BOOLEAN *par_suspend = NULL)
 : ptr_suspend(par_suspend) { }
virtual ~RSLEM__suspend_call_redirect() { }
virtual void set_parameters(const RSLEM__suspend_call& call_par) const;
};

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

class RSLEM__suspend_reply_redirect {
public:
inline void set_parameters(const RSLEM__suspend_reply&) const {}
};

class RSLEM__suspend_template {
BOOLEAN_template param_suspend;
public:
RSLEM__suspend_template();
inline BOOLEAN_template& suspend() { return param_suspend; }
inline const BOOLEAN_template& suspend() const { return param_suspend; }
RSLEM__suspend_call create_call() const;
inline RSLEM__suspend_reply create_reply() const { return RSLEM__suspend_reply(); }
boolean match_call(const RSLEM__suspend_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const RSLEM__suspend_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const RSLEM__suspend_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RSLEM__suspend_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RSLEM__wait__queue_call {
BOOLEAN param_enable;
public:
inline BOOLEAN& enable() { return param_enable; }
inline const BOOLEAN& enable() const { return param_enable; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RSLEM__wait__queue_call_redirect {
BOOLEAN *ptr_enable;
public:
RSLEM__wait__queue_call_redirect(BOOLEAN *par_enable = NULL)
 : ptr_enable(par_enable) { }
virtual ~RSLEM__wait__queue_call_redirect() { }
virtual void set_parameters(const RSLEM__wait__queue_call& call_par) const;
};

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

class RSLEM__wait__queue_reply_redirect {
public:
inline void set_parameters(const RSLEM__wait__queue_reply&) const {}
};

class RSLEM__wait__queue_template {
BOOLEAN_template param_enable;
public:
RSLEM__wait__queue_template();
inline BOOLEAN_template& enable() { return param_enable; }
inline const BOOLEAN_template& enable() const { return param_enable; }
RSLEM__wait__queue_call create_call() const;
inline RSLEM__wait__queue_reply create_reply() const { return RSLEM__wait__queue_reply(); }
boolean match_call(const RSLEM__wait__queue_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const RSLEM__wait__queue_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const RSLEM__wait__queue_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RSLEM__wait__queue_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RSLEM__get__last__act_call {
INTEGER param_trx__nr;
GSM__Types::RslChannelNr param_chan__nr;
public:
inline INTEGER& trx__nr() { return param_trx__nr; }
inline const INTEGER& trx__nr() const { return param_trx__nr; }
inline GSM__Types::RslChannelNr& chan__nr() { return param_chan__nr; }
inline const GSM__Types::RslChannelNr& chan__nr() const { return param_chan__nr; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RSLEM__get__last__act_call_redirect {
INTEGER *ptr_trx__nr;
GSM__Types::RslChannelNr *ptr_chan__nr;
public:
RSLEM__get__last__act_call_redirect(INTEGER *par_trx__nr = NULL, GSM__Types::RslChannelNr *par_chan__nr = NULL)
 : ptr_trx__nr(par_trx__nr), ptr_chan__nr(par_chan__nr) { }
virtual ~RSLEM__get__last__act_call_redirect() { }
virtual void set_parameters(const RSLEM__get__last__act_call& call_par) const;
};

class RSLEM__get__last__act_reply {
RSL__Types::RSL__Message param_chan__act;
public:
inline RSL__Types::RSL__Message& chan__act() { return param_chan__act; }
inline const RSL__Types::RSL__Message& chan__act() const { return param_chan__act; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RSLEM__get__last__act_reply_redirect {
RSL__Types::RSL__Message *ptr_chan__act;
public:
RSLEM__get__last__act_reply_redirect(RSL__Types::RSL__Message *par_chan__act = NULL)
 : ptr_chan__act(par_chan__act) { }
virtual ~RSLEM__get__last__act_reply_redirect() { }
virtual void set_parameters(const RSLEM__get__last__act_reply& reply_par) const;
};

class RSLEM__get__last__act_template {
INTEGER_template param_trx__nr;
GSM__Types::RslChannelNr_template param_chan__nr;
RSL__Types::RSL__Message_template param_chan__act;
public:
RSLEM__get__last__act_template();
inline INTEGER_template& trx__nr() { return param_trx__nr; }
inline const INTEGER_template& trx__nr() const { return param_trx__nr; }
inline GSM__Types::RslChannelNr_template& chan__nr() { return param_chan__nr; }
inline const GSM__Types::RslChannelNr_template& chan__nr() const { return param_chan__nr; }
inline RSL__Types::RSL__Message_template& chan__act() { return param_chan__act; }
inline const RSL__Types::RSL__Message_template& chan__act() const { return param_chan__act; }
RSLEM__get__last__act_call create_call() const;
RSLEM__get__last__act_reply create_reply() const;
boolean match_call(const RSLEM__get__last__act_call& match_value, boolean legacy = FALSE) const;
boolean match_reply(const RSLEM__get__last__act_reply& match_value, boolean legacy = FALSE) const;
void log() const;
void log_match_call(const RSLEM__get__last__act_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RSLEM__get__last__act_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RSLEM__set__auto__chan__act__ack_call {
BOOLEAN param_enable;
public:
inline BOOLEAN& enable() { return param_enable; }
inline const BOOLEAN& enable() const { return param_enable; }
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void log() const;
};

class RSLEM__set__auto__chan__act__ack_call_redirect {
BOOLEAN *ptr_enable;
public:
RSLEM__set__auto__chan__act__ack_call_redirect(BOOLEAN *par_enable = NULL)
 : ptr_enable(par_enable) { }
virtual ~RSLEM__set__auto__chan__act__ack_call_redirect() { }
virtual void set_parameters(const RSLEM__set__auto__chan__act__ack_call& call_par) const;
};

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

class RSLEM__set__auto__chan__act__ack_reply_redirect {
public:
inline void set_parameters(const RSLEM__set__auto__chan__act__ack_reply&) const {}
};

class RSLEM__set__auto__chan__act__ack_template {
BOOLEAN_template param_enable;
public:
RSLEM__set__auto__chan__act__ack_template();
inline BOOLEAN_template& enable() { return param_enable; }
inline const BOOLEAN_template& enable() const { return param_enable; }
RSLEM__set__auto__chan__act__ack_call create_call() const;
inline RSLEM__set__auto__chan__act__ack_reply create_reply() const { return RSLEM__set__auto__chan__act__ack_reply(); }
boolean match_call(const RSLEM__set__auto__chan__act__ack_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const RSLEM__set__auto__chan__act__ack_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const RSLEM__set__auto__chan__act__ack_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const RSLEM__set__auto__chan__act__ack_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RSLEM__PROC__PT : public PORT {
enum proc_selection { CALL_0, CALL_1, CALL_2, CALL_3, CALL_4, CALL_5, REPLY_0, REPLY_1, REPLY_2, REPLY_3, REPLY_4, REPLY_5 };
struct proc_queue_item {
proc_selection item_selection;
union {
RSLEM__register_call *call_0;
RSLEM__unregister_call *call_1;
RSLEM__suspend_call *call_2;
RSLEM__wait__queue_call *call_3;
RSLEM__get__last__act_call *call_4;
RSLEM__set__auto__chan__act__ack_call *call_5;
RSLEM__register_reply *reply_0;
RSLEM__unregister_reply *reply_1;
RSLEM__suspend_reply *reply_2;
RSLEM__wait__queue_reply *reply_3;
RSLEM__get__last__act_reply *reply_4;
RSLEM__set__auto__chan__act__ack_reply *reply_5;
};
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:
RSLEM__PROC__PT(const char *par_port_name = NULL);
~RSLEM__PROC__PT();
void call(const RSLEM__register_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__register_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__register_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__unregister_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__unregister_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__unregister_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__suspend_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__suspend_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__suspend_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__wait__queue_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__wait__queue_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__wait__queue_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__get__last__act_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__get__last__act_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__get__last__act_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__set__auto__chan__act__ack_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__set__auto__chan__act__ack_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const RSLEM__set__auto__chan__act__ack_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__register_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__register_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__register_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__unregister_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__unregister_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__unregister_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__suspend_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__suspend_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__suspend_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__wait__queue_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__wait__queue_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__wait__queue_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__get__last__act_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__get__last__act_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__get__last__act_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__set__auto__chan__act__ack_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__set__auto__chan__act__ack_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const RSLEM__set__auto__chan__act__ack_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 RSLEM__register_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__register_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RSLEM__register_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__register_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RSLEM__unregister_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__unregister_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RSLEM__unregister_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__unregister_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RSLEM__suspend_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__suspend_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RSLEM__suspend_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__suspend_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RSLEM__wait__queue_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__wait__queue_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RSLEM__wait__queue_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__wait__queue_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RSLEM__get__last__act_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__get__last__act_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RSLEM__get__last__act_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__get__last__act_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const RSLEM__set__auto__chan__act__ack_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__set__auto__chan__act__ack_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const RSLEM__set__auto__chan__act__ack_template& getcall_template, const COMPONENT_template& sender_template, const RSLEM__set__auto__chan__act__ack_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 RSLEM__register_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__register_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RSLEM__register_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__register_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RSLEM__unregister_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__unregister_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RSLEM__unregister_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__unregister_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RSLEM__suspend_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__suspend_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RSLEM__suspend_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__suspend_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RSLEM__wait__queue_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__wait__queue_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RSLEM__wait__queue_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__wait__queue_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RSLEM__get__last__act_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__get__last__act_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RSLEM__get__last__act_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__get__last__act_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const RSLEM__set__auto__chan__act__ack_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__set__auto__chan__act__ack_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const RSLEM__set__auto__chan__act__ack_template& getreply_template, const COMPONENT_template& sender_template, const RSLEM__set__auto__chan__act__ack_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_call(const RSLEM__register_call& incoming_par, component sender_component);
void incoming_call(const RSLEM__unregister_call& incoming_par, component sender_component);
void incoming_call(const RSLEM__suspend_call& incoming_par, component sender_component);
void incoming_call(const RSLEM__wait__queue_call& incoming_par, component sender_component);
void incoming_call(const RSLEM__get__last__act_call& incoming_par, component sender_component);
void incoming_call(const RSLEM__set__auto__chan__act__ack_call& incoming_par, component sender_component);
void incoming_reply(const RSLEM__register_reply& incoming_par, component sender_component);
void incoming_reply(const RSLEM__unregister_reply& incoming_par, component sender_component);
void incoming_reply(const RSLEM__suspend_reply& incoming_par, component sender_component);
void incoming_reply(const RSLEM__wait__queue_reply& incoming_par, component sender_component);
void incoming_reply(const RSLEM__get__last__act_reply& incoming_par, component sender_component);
void incoming_reply(const RSLEM__set__auto__chan__act__ack_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 ConnectionData {
  COMPONENT field_comp__ref;
  OPTIONAL< INTEGER > field_trx__nr;
  OPTIONAL< IPA__Types::IpaStreamId > field_stream__id;
  OPTIONAL< GSM__Types::RslChannelNr > field_chan__nr;
  OPTIONAL< OCTETSTRING > field_ra;
  OPTIONAL< INTEGER > field_ra__fn;
public:
  ConnectionData();
  ConnectionData(const COMPONENT& par_comp__ref,
    const OPTIONAL< INTEGER >& par_trx__nr,
    const OPTIONAL< IPA__Types::IpaStreamId >& par_stream__id,
    const OPTIONAL< GSM__Types::RslChannelNr >& par_chan__nr,
    const OPTIONAL< OCTETSTRING >& par_ra,
    const OPTIONAL< INTEGER >& par_ra__fn);
  ConnectionData(const ConnectionData& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  ConnectionData& operator=(const ConnectionData& other_value);
  boolean operator==(const ConnectionData& other_value) const;
  inline boolean operator!=(const ConnectionData& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline COMPONENT& comp__ref()
    {return field_comp__ref;}
  inline const COMPONENT& comp__ref() const
    {return field_comp__ref;}
  inline OPTIONAL< INTEGER >& trx__nr()
    {return field_trx__nr;}
  inline const OPTIONAL< INTEGER >& trx__nr() const
    {return field_trx__nr;}
  inline OPTIONAL< IPA__Types::IpaStreamId >& stream__id()
    {return field_stream__id;}
  inline const OPTIONAL< IPA__Types::IpaStreamId >& stream__id() const
    {return field_stream__id;}
  inline OPTIONAL< GSM__Types::RslChannelNr >& chan__nr()
    {return field_chan__nr;}
  inline const OPTIONAL< GSM__Types::RslChannelNr >& chan__nr() const
    {return field_chan__nr;}
  inline OPTIONAL< OCTETSTRING >& ra()
    {return field_ra;}
  inline const OPTIONAL< OCTETSTRING >& ra() const
    {return field_ra;}
  inline OPTIONAL< INTEGER >& ra__fn()
    {return field_ra__fn;}
  inline const OPTIONAL< INTEGER >& ra__fn() const
    {return field_ra__fn;}
  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 ConnectionData_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
ConnectionData_template *list_value;
} value_list;
struct {
ConnectionData_template* precondition;
ConnectionData_template* implied_template;
} implication_;
dynmatch_struct<ConnectionData>* dyn_match;
};

void set_specific();
void copy_value(const ConnectionData& other_value);
void copy_template(const ConnectionData_template& other_value);

public:
ConnectionData_template();
ConnectionData_template(template_sel other_value);
ConnectionData_template(const ConnectionData& other_value);
ConnectionData_template(const OPTIONAL<ConnectionData>& other_value);
ConnectionData_template(ConnectionData_template* p_precondition, ConnectionData_template* p_implied_template);
ConnectionData_template(Dynamic_Match_Interface<ConnectionData>* p_dyn_match);
ConnectionData_template(const ConnectionData_template& other_value);
~ConnectionData_template();
ConnectionData_template& operator=(template_sel other_value);
ConnectionData_template& operator=(const ConnectionData& other_value);
ConnectionData_template& operator=(const OPTIONAL<ConnectionData>& other_value);
ConnectionData_template& operator=(const ConnectionData_template& other_value);
boolean match(const ConnectionData& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
ConnectionData valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
ConnectionData_template& list_item(unsigned int list_index) const;
COMPONENT_template& comp__ref();
const COMPONENT_template& comp__ref() const;
INTEGER_template& trx__nr();
const INTEGER_template& trx__nr() const;
IPA__Types::IpaStreamId_template& stream__id();
const IPA__Types::IpaStreamId_template& stream__id() const;
GSM__Types::RslChannelNr_template& chan__nr();
const GSM__Types::RslChannelNr_template& chan__nr() const;
OCTETSTRING_template& ra();
const OCTETSTRING_template& ra() const;
INTEGER_template& ra__fn();
const INTEGER_template& ra__fn() const;
int size_of() const;
void log() const;
void log_match(const ConnectionData& 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 LastActData {
  OPTIONAL< INTEGER > field_trx__nr;
  OPTIONAL< GSM__Types::RslChannelNr > field_chan__nr;
  OPTIONAL< RSL__Types::RSL__Message > field_chan__act;
public:
  LastActData();
  LastActData(const OPTIONAL< INTEGER >& par_trx__nr,
    const OPTIONAL< GSM__Types::RslChannelNr >& par_chan__nr,
    const OPTIONAL< RSL__Types::RSL__Message >& par_chan__act);
  LastActData(const LastActData& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  LastActData& operator=(const LastActData& other_value);
  boolean operator==(const LastActData& other_value) const;
  inline boolean operator!=(const LastActData& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OPTIONAL< INTEGER >& trx__nr()
    {return field_trx__nr;}
  inline const OPTIONAL< INTEGER >& trx__nr() const
    {return field_trx__nr;}
  inline OPTIONAL< GSM__Types::RslChannelNr >& chan__nr()
    {return field_chan__nr;}
  inline const OPTIONAL< GSM__Types::RslChannelNr >& chan__nr() const
    {return field_chan__nr;}
  inline OPTIONAL< RSL__Types::RSL__Message >& chan__act()
    {return field_chan__act;}
  inline const OPTIONAL< RSL__Types::RSL__Message >& chan__act() const
    {return field_chan__act;}
  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 LastActData_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
LastActData_template *list_value;
} value_list;
struct {
LastActData_template* precondition;
LastActData_template* implied_template;
} implication_;
dynmatch_struct<LastActData>* dyn_match;
};

void set_specific();
void copy_value(const LastActData& other_value);
void copy_template(const LastActData_template& other_value);

public:
LastActData_template();
LastActData_template(template_sel other_value);
LastActData_template(const LastActData& other_value);
LastActData_template(const OPTIONAL<LastActData>& other_value);
LastActData_template(LastActData_template* p_precondition, LastActData_template* p_implied_template);
LastActData_template(Dynamic_Match_Interface<LastActData>* p_dyn_match);
LastActData_template(const LastActData_template& other_value);
~LastActData_template();
LastActData_template& operator=(template_sel other_value);
LastActData_template& operator=(const LastActData& other_value);
LastActData_template& operator=(const OPTIONAL<LastActData>& other_value);
LastActData_template& operator=(const LastActData_template& other_value);
boolean match(const LastActData& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
LastActData valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
LastActData_template& list_item(unsigned int list_index) const;
INTEGER_template& trx__nr();
const INTEGER_template& trx__nr() const;
GSM__Types::RslChannelNr_template& chan__nr();
const GSM__Types::RslChannelNr_template& chan__nr() const;
RSL__Types::RSL__Message_template& chan__act();
const RSL__Types::RSL__Message_template& chan__act() const;
int size_of() const;
void log() const;
void log_match(const LastActData& 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 ASP__RSL__UDList : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
IPA__Emulation::ASP__RSL__Unitdata **value_elements;
} *val_ptr;

static const IPA__Emulation::ASP__RSL__Unitdata UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const ASP__RSL__UDList& other_value);

public:
  typedef IPA__Emulation::ASP__RSL__Unitdata of_type;
ASP__RSL__UDList();
ASP__RSL__UDList(null_type other_value);
ASP__RSL__UDList(const ASP__RSL__UDList& other_value);
~ASP__RSL__UDList();

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

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

IPA__Emulation::ASP__RSL__Unitdata& operator[](int index_value);
IPA__Emulation::ASP__RSL__Unitdata& operator[](const INTEGER& index_value);
const IPA__Emulation::ASP__RSL__Unitdata& operator[](int index_value) const;
const IPA__Emulation::ASP__RSL__Unitdata& operator[](const INTEGER& index_value) const;

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

ASP__RSL__UDList operator+(const ASP__RSL__UDList& other_value) const;

ASP__RSL__UDList substr(int index, int returncount) const;

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

ASP__RSL__UDList replace(int index, int len, const ASP__RSL__UDList_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 ASP__RSL__UDList_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
IPA__Emulation::ASP__RSL__Unitdata_template **value_elements;
} single_value;
struct {
unsigned int n_values;
ASP__RSL__UDList_template *list_value;
} value_list;
struct {
ASP__RSL__UDList_template* precondition;
ASP__RSL__UDList_template* implied_template;
} implication_;
dynmatch_struct<ASP__RSL__UDList>* dyn_match;
};
void copy_value(const ASP__RSL__UDList& other_value);
void copy_template(const ASP__RSL__UDList_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:
ASP__RSL__UDList_template();
ASP__RSL__UDList_template(template_sel other_value);
ASP__RSL__UDList_template(null_type other_value);
ASP__RSL__UDList_template(const ASP__RSL__UDList& other_value);
ASP__RSL__UDList_template(const OPTIONAL<ASP__RSL__UDList>& other_value);
ASP__RSL__UDList_template(ASP__RSL__UDList_template* p_precondition, ASP__RSL__UDList_template* p_implied_template);
ASP__RSL__UDList_template(Dynamic_Match_Interface<ASP__RSL__UDList>* p_dyn_match);
ASP__RSL__UDList_template(const ASP__RSL__UDList_template& other_value);
~ASP__RSL__UDList_template();

void clean_up();
ASP__RSL__UDList_template& operator=(template_sel other_value);
ASP__RSL__UDList_template& operator=(null_type other_value);
ASP__RSL__UDList_template& operator=(const ASP__RSL__UDList& other_value);
ASP__RSL__UDList_template& operator=(const OPTIONAL<ASP__RSL__UDList>& other_value);
ASP__RSL__UDList_template& operator=(const ASP__RSL__UDList_template& other_value);

IPA__Emulation::ASP__RSL__Unitdata_template& operator[](int index_value);
IPA__Emulation::ASP__RSL__Unitdata_template& operator[](const INTEGER& index_value);
const IPA__Emulation::ASP__RSL__Unitdata_template& operator[](int index_value) const;
const IPA__Emulation::ASP__RSL__Unitdata_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 ASP__RSL__UDList& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
ASP__RSL__UDList valueof() const;
ASP__RSL__UDList substr(int index, int returncount) const;

ASP__RSL__UDList replace(int index, int len, const ASP__RSL__UDList_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
ASP__RSL__UDList_template& list_item(unsigned int list_index);
void log() const;
void log_match(const ASP__RSL__UDList& 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;
};


/* Function prototypes */

extern RSLDC__ChanRqd_template ts__RSLDC__ChanRqd(const OCTETSTRING& ra, const INTEGER& fn);
extern RSLDC__ChanRqd_template ts__RSLDC__ChanRqd__anyFN(const OCTETSTRING& ra);
extern RSLEm__Event_template ts__RSLEm__EV(const RSLEm__EventType& ev__type, const IPA__Types::IpaStreamId& sid);
extern RSLEm__Event_template tr__RSLEm__EV(const RSLEm__EventType_template& ev__type, const IPA__Types::IpaStreamId_template& sid);
extern RSL__Types::RSL__Message f__rx__or__fail(const RSL__Types::RSL__Message_template& exp__rx, RSL__DCHAN__PT& rsl__pt);
extern void f__chan__act__verify__tsc(const RSL__Types::RSL__Message& chan__act, const INTEGER_template& tsc);
extern void f__chan__est(const OCTETSTRING& ra, const OCTETSTRING& est__l3, const GSM__Types::RslLinkId_template& link__id, const INTEGER& fn, const INTEGER_template& tsc, RSL__DCHAN__PT& rsl__pt, RSLEM__PROC__PT& rsl__proc__pt);
extern void f__deact__chan(const RSL__Types::RSL__Cause& cause);
extern void start_f__deact__chan(const COMPONENT& component_reference, const RSL__Types::RSL__Cause& cause);
extern INTEGER f__cid__by__comp__ref(const COMPONENT& comp__ref);
extern void start_f__cid__by__comp__ref(const COMPONENT& component_reference, const COMPONENT& comp__ref);
extern INTEGER f__cid__by__chan__nr(const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr);
extern void start_f__cid__by__chan__nr(const COMPONENT& component_reference, const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr);
extern INTEGER f__cid__by__ra__fn(const OCTETSTRING& ra, const INTEGER& fn);
extern void start_f__cid__by__ra__fn(const COMPONENT& component_reference, const OCTETSTRING& ra, const INTEGER& fn);
extern INTEGER f__cid__by__ra__fn2(const OCTETSTRING& ra, const RSL__Types::RSL__IE__FrameNumber& fn);
extern void start_f__cid__by__ra__fn2(const COMPONENT& component_reference, const OCTETSTRING& ra, const RSL__Types::RSL__IE__FrameNumber& fn);
extern void f__cid__create(const OCTETSTRING& ra, const INTEGER_template& fn, const COMPONENT& comp__ref);
extern void start_f__cid__create(const COMPONENT& component_reference, const OCTETSTRING& ra, const INTEGER_template& fn, const COMPONENT& comp__ref);
extern void f__cid__create__cnr(const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr, const COMPONENT& comp__ref);
extern void start_f__cid__create__cnr(const COMPONENT& component_reference, const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr, const COMPONENT& comp__ref);
extern INTEGER f__cid__delete__cnr(const IPA__Types::IpaStreamId& stream__id, const GSM__Types::RslChannelNr& chan__nr, const COMPONENT& comp__ref);
extern void start_f__cid__delete__cnr(const COMPONENT& component_reference, const IPA__Types::IpaStreamId& stream__id, const GSM__Types::RslChannelNr& chan__nr, const COMPONENT& comp__ref);
extern void f__cid__clear(const INTEGER& cid);
extern void start_f__cid__clear(const COMPONENT& component_reference, const INTEGER& cid);
extern void f__store__last__act__data(const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr, const RSL__Types::RSL__Message& chan__act);
extern void start_f__store__last__act__data(const COMPONENT& component_reference, const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr, const RSL__Types::RSL__Message& chan__act);
extern RSL__Types::RSL__Message f__lookup__last__act(const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr);
extern void start_f__lookup__last__act(const COMPONENT& component_reference, const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr);
extern void f__last__act__table__init();
extern void start_f__last__act__table__init(const COMPONENT& component_reference);
extern void f__trx__conn__map__init();
extern void start_f__trx__conn__map__init(const COMPONENT& component_reference);
extern IPA__Types::IpaStreamId f__trx__conn__map__register(const INTEGER& conn__id, const IPA__Types::IpaCcmIdResp& id__resp);
extern void start_f__trx__conn__map__register(const COMPONENT& component_reference, const INTEGER& conn__id, const IPA__Types::IpaCcmIdResp& id__resp);
extern IPA__Types::IpaStreamId f__trx__conn__map__unregister(const INTEGER& conn__id);
extern void start_f__trx__conn__map__unregister(const COMPONENT& component_reference, const INTEGER& conn__id);
extern INTEGER f__trx__conn__map__resolve(const IPA__Types::IpaStreamId& id);
extern void start_f__trx__conn__map__resolve(const COMPONENT& component_reference, const IPA__Types::IpaStreamId& id);
extern boolean operator==(null_type null_value, const ASP__RSL__UDList& other_value);
inline boolean operator!=(null_type null_value, const ASP__RSL__UDList& other_value) { return !(null_value == other_value); }
extern INTEGER f__trx__by__streamId(const IPA__Types::IpaStreamId& id);
extern IPA__Types::IpaStreamId f__streamId__by__trx(const INTEGER& trx__nr);
extern void main_(const BOOLEAN& bts__role);
extern void start_main_(const COMPONENT& component_reference, const BOOLEAN& bts__role);
extern void f__conn__table__init();
extern void start_f__conn__table__init(const COMPONENT& component_reference);
extern void f__WaitingQueue__dispatch();
extern void start_f__WaitingQueue__dispatch(const COMPONENT& component_reference);
extern void f__rslem__register(const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr, RSLEM__PROC__PT& PT);
extern void f__rslem__unregister(const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr, RSLEM__PROC__PT& PT);
extern void f__rslem__suspend(RSLEM__PROC__PT& PT);
extern void f__rslem__resume(RSLEM__PROC__PT& PT);
extern void f__rslem__dchan__queue__enable(RSLEM__PROC__PT& PT);
extern void f__rslem__dchan__queue__dispatch(RSLEM__PROC__PT& PT);
extern RSL__Types::RSL__Message f__rslem__get__last__act(RSLEM__PROC__PT& PT, const INTEGER& trx__nr, const GSM__Types::RslChannelNr& chan__nr);
extern void f__rslem__set__auto__chan__act__ack(RSLEM__PROC__PT& PT, const BOOLEAN& enable);
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& RSL__DchanHdlr_descr_;
extern RSL__DCHAN__PT RSL__DchanHdlr_component_RSL;
extern RSLEM__PROC__PT RSL__DchanHdlr_component_RSL__PROC;
extern GSM__Types::RslChannelNr RSL__DchanHdlr_component_g__chan__nr;
extern RSL__DCHAN__PT RSL__DchanHdlr_component_RSL1;
extern RSLEM__PROC__PT RSL__DchanHdlr_component_RSL1__PROC;
extern RSL__DCHAN__PT RSL__DchanHdlr_component_RSL2;
extern RSLEM__PROC__PT RSL__DchanHdlr_component_RSL2__PROC;
extern const XERdescriptor_t RSLDC__ChanRqd_ra_xer_;
extern const TTCN_OERdescriptor_t RSLDC__ChanRqd_ra_oer_;
extern const TTCN_Typedescriptor_t RSLDC__ChanRqd_ra_descr_;
extern UNIVERSAL_CHARSTRING RSLDC__ChanRqd_ra_default_coding;
extern const TTCN_Typedescriptor_t RSLDC__ChanRqd_descr_;
extern const XERdescriptor_t RSLDC__ChanRqd_fn_xer_;
extern const TTCN_OERdescriptor_t RSLDC__ChanRqd_fn_oer_;
extern const TTCN_Typedescriptor_t RSLDC__ChanRqd_fn_descr_;
extern UNIVERSAL_CHARSTRING RSLDC__ChanRqd_fn_default_coding;
extern const TTCN_Typedescriptor_t RSLEm__EventType_descr_;
extern UNIVERSAL_CHARSTRING RSLEm__Event_sid_default_coding;
extern const TTCN_Typedescriptor_t RSLEm__Event_descr_;
extern const IPA__Types::IpaStreamId_template& tr__RSLEm__EV_sid_defval;
extern IPA__Types::IpaStreamId_template template_tr__RSLEm__EV_sid_defval;
extern const INTEGER& f__chan__est_fn_defval;
extern INTEGER const_f__chan__est_fn_defval;
extern const INTEGER_template& f__chan__est_tsc_defval;
extern INTEGER_template template_f__chan__est_tsc_defval;
extern const TTCN_Typedescriptor_t ConnectionData_descr_;
extern const XERdescriptor_t ConnectionData_trx__nr_xer_;
extern const TTCN_OERdescriptor_t ConnectionData_trx__nr_oer_;
extern const TTCN_Typedescriptor_t ConnectionData_trx__nr_descr_;
extern UNIVERSAL_CHARSTRING ConnectionData_trx__nr_default_coding;
extern UNIVERSAL_CHARSTRING ConnectionData_stream__id_default_coding;
extern UNIVERSAL_CHARSTRING ConnectionData_chan__nr_default_coding;
extern const XERdescriptor_t ConnectionData_ra_xer_;
extern const TTCN_OERdescriptor_t ConnectionData_ra_oer_;
extern const TTCN_Typedescriptor_t ConnectionData_ra_descr_;
extern UNIVERSAL_CHARSTRING ConnectionData_ra_default_coding;
extern const XERdescriptor_t ConnectionData_ra__fn_xer_;
extern const TTCN_OERdescriptor_t ConnectionData_ra__fn_oer_;
extern const TTCN_Typedescriptor_t ConnectionData_ra__fn_descr_;
extern UNIVERSAL_CHARSTRING ConnectionData_ra__fn_default_coding;
extern const TTCN_Typedescriptor_t LastActData_descr_;
extern const XERdescriptor_t LastActData_trx__nr_xer_;
extern const TTCN_OERdescriptor_t LastActData_trx__nr_oer_;
extern const TTCN_Typedescriptor_t LastActData_trx__nr_descr_;
extern UNIVERSAL_CHARSTRING LastActData_trx__nr_default_coding;
extern UNIVERSAL_CHARSTRING LastActData_chan__nr_default_coding;
extern UNIVERSAL_CHARSTRING LastActData_chan__act_default_coding;
extern const TTCN_Typedescriptor_t ASP__RSL__UDList_descr_;
extern const TTCN_Typedescriptor_t& RSL__Emulation__CT_descr_;
extern IPA__Emulation::IPA__RSL__PT RSL__Emulation__CT_component_IPA__PT;
extern RSL__DCHAN__PT RSL__Emulation__CT_component_CLIENT__PT;
extern RSLEM__PROC__PT RSL__Emulation__CT_component_RSL__PROC;
extern RSL__CCHAN__PT RSL__Emulation__CT_component_CCHAN__PT;
extern VALUE_ARRAY<ConnectionData, 64, 0> RSL__Emulation__CT_component_ConnectionTable;
extern ASP__RSL__UDList RSL__Emulation__CT_component_WaitingQueue;
extern VALUE_ARRAY<LastActData, 64, 0> RSL__Emulation__CT_component_LastActTable;
extern INTEGER RSL__Emulation__CT_component_TrxConnNum;
extern VALUE_ARRAY<INTEGER, 4, 0> RSL__Emulation__CT_component_TrxConnMap;
extern const BOOLEAN& main__bts__role_defval;
extern BOOLEAN const_main__bts__role_defval;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif