// 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 MGCP__Emulation_HH
#define MGCP__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 "MGCP_CodecPort_CtrlFunct.hh"
#include "MGCP_Templates.hh"
#include "Osmocom_Types.hh"
#include "Misc_Helpers.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 MGCP__Emulation_HH
#endif

namespace MGCP__Emulation {

/* Forward declarations of classes */

class MGCP__Conn__PT;
class MGCP__Conn__Multi__PT;
class EndpointData;
class EndpointData_template;
typedef PreGenRecordOf::PREGEN__SET__OF__CHARSTRING MgcpTransIds;
typedef PreGenRecordOf::PREGEN__SET__OF__CHARSTRING_template MgcpTransIds_template;
class ExpectData;
class ExpectData_template;
class ExpectCriteria;
class ExpectCriteria_template;
class MGCP__conn__parameters;
class MGCP__conn__parameters_template;
class MGCPCreateCallback;
class MGCPCreateCallback_template;
class MGCPUnitdataCallback;
class MGCPUnitdataCallback_template;
class MGCPOps;
class MGCPOps_template;
class MGCPEM__register_call;
class MGCPEM__register_call_redirect;
class MGCPEM__register_reply;
class MGCPEM__register_reply_redirect;
class MGCPEM__register_template;
class MGCPEM__delete__ep_call;
class MGCPEM__delete__ep_call_redirect;
class MGCPEM__delete__ep_reply;
class MGCPEM__delete__ep_reply_redirect;
class MGCPEM__delete__ep_template;
class MGCPEM__change__connhdlr_call;
class MGCPEM__change__connhdlr_call_redirect;
class MGCPEM__change__connhdlr_reply;
class MGCPEM__change__connhdlr_reply_redirect;
class MGCPEM__change__connhdlr_template;
class MGCPEM__PROC__PT;

} /* end of namespace */

#ifndef MGCP__Emulation_HH
#define MGCP__Emulation_HH

namespace MGCP__Emulation {

/* Type definitions */

typedef COMPONENT MGCP__ConnHdlr;
typedef COMPONENT_template MGCP__ConnHdlr_template;
typedef COMPONENT MGCP__Emulation__CT;
typedef COMPONENT_template MGCP__Emulation__CT_template;

/* Class definitions */

class MGCP__Conn__PT : public PORT {
enum msg_selection { MESSAGE_0, MESSAGE_1 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
MGCP__Types::MgcpCommand *message_0;
MGCP__Types::MgcpResponse *message_1;
};
component sender_component;
};

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

class MGCP__Conn__Multi__PT : public PORT {
enum msg_selection { MESSAGE_0, MESSAGE_1 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
MGCP__CodecPort::MGCP__RecvFrom *message_0;
MGCP__CodecPort::MGCP__SendTo *message_1;
};
component sender_component;
};

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

class EndpointData {
  COMPONENT field_comp__ref;
  OPTIONAL< CHARSTRING > field_endpoint;
public:
  EndpointData();
  EndpointData(const COMPONENT& par_comp__ref,
    const OPTIONAL< CHARSTRING >& par_endpoint);
  EndpointData(const EndpointData& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  EndpointData& operator=(const EndpointData& other_value);
  boolean operator==(const EndpointData& other_value) const;
  inline boolean operator!=(const EndpointData& 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< CHARSTRING >& endpoint()
    {return field_endpoint;}
  inline const OPTIONAL< CHARSTRING >& endpoint() const
    {return field_endpoint;}
  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 EndpointData_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
EndpointData_template *list_value;
} value_list;
struct {
EndpointData_template* precondition;
EndpointData_template* implied_template;
} implication_;
dynmatch_struct<EndpointData>* dyn_match;
};

void set_specific();
void copy_value(const EndpointData& other_value);
void copy_template(const EndpointData_template& other_value);

public:
EndpointData_template();
EndpointData_template(template_sel other_value);
EndpointData_template(const EndpointData& other_value);
EndpointData_template(const OPTIONAL<EndpointData>& other_value);
EndpointData_template(EndpointData_template* p_precondition, EndpointData_template* p_implied_template);
EndpointData_template(Dynamic_Match_Interface<EndpointData>* p_dyn_match);
EndpointData_template(const EndpointData_template& other_value);
~EndpointData_template();
EndpointData_template& operator=(template_sel other_value);
EndpointData_template& operator=(const EndpointData& other_value);
EndpointData_template& operator=(const OPTIONAL<EndpointData>& other_value);
EndpointData_template& operator=(const EndpointData_template& other_value);
boolean match(const EndpointData& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
EndpointData valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
EndpointData_template& list_item(unsigned int list_index) const;
COMPONENT_template& comp__ref();
const COMPONENT_template& comp__ref() const;
CHARSTRING_template& endpoint();
const CHARSTRING_template& endpoint() const;
int size_of() const;
void log() const;
void log_match(const EndpointData& 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 ExpectData {
  OPTIONAL< ExpectCriteria > field_crit;
  COMPONENT field_vc__conn;
public:
  ExpectData();
  ExpectData(const OPTIONAL< ExpectCriteria >& par_crit,
    const COMPONENT& par_vc__conn);
  ExpectData(const ExpectData& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  ExpectData& operator=(const ExpectData& other_value);
  boolean operator==(const ExpectData& other_value) const;
  inline boolean operator!=(const ExpectData& 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< ExpectCriteria >& crit()
    {return field_crit;}
  inline const OPTIONAL< ExpectCriteria >& crit() const
    {return field_crit;}
  inline COMPONENT& vc__conn()
    {return field_vc__conn;}
  inline const COMPONENT& vc__conn() const
    {return field_vc__conn;}
  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 ExpectData_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
ExpectData_template *list_value;
} value_list;
struct {
ExpectData_template* precondition;
ExpectData_template* implied_template;
} implication_;
dynmatch_struct<ExpectData>* dyn_match;
};

void set_specific();
void copy_value(const ExpectData& other_value);
void copy_template(const ExpectData_template& other_value);

public:
ExpectData_template();
ExpectData_template(template_sel other_value);
ExpectData_template(const ExpectData& other_value);
ExpectData_template(const OPTIONAL<ExpectData>& other_value);
ExpectData_template(ExpectData_template* p_precondition, ExpectData_template* p_implied_template);
ExpectData_template(Dynamic_Match_Interface<ExpectData>* p_dyn_match);
ExpectData_template(const ExpectData_template& other_value);
~ExpectData_template();
ExpectData_template& operator=(template_sel other_value);
ExpectData_template& operator=(const ExpectData& other_value);
ExpectData_template& operator=(const OPTIONAL<ExpectData>& other_value);
ExpectData_template& operator=(const ExpectData_template& other_value);
boolean match(const ExpectData& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
ExpectData valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
ExpectData_template& list_item(unsigned int list_index) const;
ExpectCriteria_template& crit();
const ExpectCriteria_template& crit() const;
COMPONENT_template& vc__conn();
const COMPONENT_template& vc__conn() const;
int size_of() const;
void log() const;
void log_match(const ExpectData& 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 ExpectCriteria {
  OPTIONAL< HEXSTRING > field_connid;
  OPTIONAL< CHARSTRING > field_endpoint;
  OPTIONAL< CHARSTRING > field_transid;
public:
  ExpectCriteria();
  ExpectCriteria(const OPTIONAL< HEXSTRING >& par_connid,
    const OPTIONAL< CHARSTRING >& par_endpoint,
    const OPTIONAL< CHARSTRING >& par_transid);
  ExpectCriteria(const ExpectCriteria& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  ExpectCriteria& operator=(const ExpectCriteria& other_value);
  boolean operator==(const ExpectCriteria& other_value) const;
  inline boolean operator!=(const ExpectCriteria& 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< HEXSTRING >& connid()
    {return field_connid;}
  inline const OPTIONAL< HEXSTRING >& connid() const
    {return field_connid;}
  inline OPTIONAL< CHARSTRING >& endpoint()
    {return field_endpoint;}
  inline const OPTIONAL< CHARSTRING >& endpoint() const
    {return field_endpoint;}
  inline OPTIONAL< CHARSTRING >& transid()
    {return field_transid;}
  inline const OPTIONAL< CHARSTRING >& transid() const
    {return field_transid;}
  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 ExpectCriteria_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
ExpectCriteria_template *list_value;
} value_list;
struct {
ExpectCriteria_template* precondition;
ExpectCriteria_template* implied_template;
} implication_;
dynmatch_struct<ExpectCriteria>* dyn_match;
};

void set_specific();
void copy_value(const ExpectCriteria& other_value);
void copy_template(const ExpectCriteria_template& other_value);

public:
ExpectCriteria_template();
ExpectCriteria_template(template_sel other_value);
ExpectCriteria_template(const ExpectCriteria& other_value);
ExpectCriteria_template(const OPTIONAL<ExpectCriteria>& other_value);
ExpectCriteria_template(ExpectCriteria_template* p_precondition, ExpectCriteria_template* p_implied_template);
ExpectCriteria_template(Dynamic_Match_Interface<ExpectCriteria>* p_dyn_match);
ExpectCriteria_template(const ExpectCriteria_template& other_value);
~ExpectCriteria_template();
ExpectCriteria_template& operator=(template_sel other_value);
ExpectCriteria_template& operator=(const ExpectCriteria& other_value);
ExpectCriteria_template& operator=(const OPTIONAL<ExpectCriteria>& other_value);
ExpectCriteria_template& operator=(const ExpectCriteria_template& other_value);
boolean match(const ExpectCriteria& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
ExpectCriteria valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
ExpectCriteria_template& list_item(unsigned int list_index) const;
HEXSTRING_template& connid();
const HEXSTRING_template& connid() const;
CHARSTRING_template& endpoint();
const CHARSTRING_template& endpoint() const;
CHARSTRING_template& transid();
const CHARSTRING_template& transid() const;
int size_of() const;
void log() const;
void log_match(const ExpectCriteria& 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 MGCP__conn__parameters {
  CHARSTRING field_callagent__ip;
  INTEGER field_callagent__udp__port;
  CHARSTRING field_mgw__ip;
  INTEGER field_mgw__udp__port;
  BOOLEAN field_multi__conn__mode;
public:
  MGCP__conn__parameters();
  MGCP__conn__parameters(const CHARSTRING& par_callagent__ip,
    const INTEGER& par_callagent__udp__port,
    const CHARSTRING& par_mgw__ip,
    const INTEGER& par_mgw__udp__port,
    const BOOLEAN& par_multi__conn__mode);
  MGCP__conn__parameters(const MGCP__conn__parameters& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  MGCP__conn__parameters& operator=(const MGCP__conn__parameters& other_value);
  boolean operator==(const MGCP__conn__parameters& other_value) const;
  inline boolean operator!=(const MGCP__conn__parameters& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline CHARSTRING& callagent__ip()
    {return field_callagent__ip;}
  inline const CHARSTRING& callagent__ip() const
    {return field_callagent__ip;}
  inline INTEGER& callagent__udp__port()
    {return field_callagent__udp__port;}
  inline const INTEGER& callagent__udp__port() const
    {return field_callagent__udp__port;}
  inline CHARSTRING& mgw__ip()
    {return field_mgw__ip;}
  inline const CHARSTRING& mgw__ip() const
    {return field_mgw__ip;}
  inline INTEGER& mgw__udp__port()
    {return field_mgw__udp__port;}
  inline const INTEGER& mgw__udp__port() const
    {return field_mgw__udp__port;}
  inline BOOLEAN& multi__conn__mode()
    {return field_multi__conn__mode;}
  inline const BOOLEAN& multi__conn__mode() const
    {return field_multi__conn__mode;}
  inline int size_of() const
    {return 5;}
  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 MGCP__conn__parameters_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
MGCP__conn__parameters_template *list_value;
} value_list;
struct {
MGCP__conn__parameters_template* precondition;
MGCP__conn__parameters_template* implied_template;
} implication_;
dynmatch_struct<MGCP__conn__parameters>* dyn_match;
};

void set_specific();
void copy_value(const MGCP__conn__parameters& other_value);
void copy_template(const MGCP__conn__parameters_template& other_value);

public:
MGCP__conn__parameters_template();
MGCP__conn__parameters_template(template_sel other_value);
MGCP__conn__parameters_template(const MGCP__conn__parameters& other_value);
MGCP__conn__parameters_template(const OPTIONAL<MGCP__conn__parameters>& other_value);
MGCP__conn__parameters_template(MGCP__conn__parameters_template* p_precondition, MGCP__conn__parameters_template* p_implied_template);
MGCP__conn__parameters_template(Dynamic_Match_Interface<MGCP__conn__parameters>* p_dyn_match);
MGCP__conn__parameters_template(const MGCP__conn__parameters_template& other_value);
~MGCP__conn__parameters_template();
MGCP__conn__parameters_template& operator=(template_sel other_value);
MGCP__conn__parameters_template& operator=(const MGCP__conn__parameters& other_value);
MGCP__conn__parameters_template& operator=(const OPTIONAL<MGCP__conn__parameters>& other_value);
MGCP__conn__parameters_template& operator=(const MGCP__conn__parameters_template& other_value);
boolean match(const MGCP__conn__parameters& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
MGCP__conn__parameters valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
MGCP__conn__parameters_template& list_item(unsigned int list_index) const;
CHARSTRING_template& callagent__ip();
const CHARSTRING_template& callagent__ip() const;
INTEGER_template& callagent__udp__port();
const INTEGER_template& callagent__udp__port() const;
CHARSTRING_template& mgw__ip();
const CHARSTRING_template& mgw__ip() const;
INTEGER_template& mgw__udp__port();
const INTEGER_template& mgw__udp__port() const;
BOOLEAN_template& multi__conn__mode();
const BOOLEAN_template& multi__conn__mode() const;
int size_of() const;
void log() const;
void log_match(const MGCP__conn__parameters& 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 MGCPCreateCallback : public Base_Type {
public:
typedef COMPONENT (*function_pointer)(const MGCP__Types::MgcpCommand& cmd, const CHARSTRING& id);
typedef void (*start_pointer)(const COMPONENT& component_reference, const MGCP__Types::MgcpCommand& cmd, const CHARSTRING& id);
private:
friend class MGCPCreateCallback_template;
friend boolean operator==(MGCPCreateCallback::function_pointer value, const MGCPCreateCallback& other_value);
function_pointer referred_function;
public:
MGCPCreateCallback();
MGCPCreateCallback(function_pointer other_value);
MGCPCreateCallback(const MGCPCreateCallback& other_value);
MGCPCreateCallback& operator=(function_pointer other_value);
MGCPCreateCallback& operator=(const MGCPCreateCallback& other_value);
boolean operator==(function_pointer other_value) const;
boolean operator==(const MGCPCreateCallback& other_value) const;
inline boolean operator!=(function_pointer other_value) const
{ return !(*this == other_value); }
inline boolean operator!=(const MGCPCreateCallback& other_value) const
{ return !(*this == other_value); }

COMPONENT invoke(const MGCP__Types::MgcpCommand& cmd, const CHARSTRING& id) const;
void start(const COMPONENT& component_reference, const MGCP__Types::MgcpCommand& cmd, const CHARSTRING& id) const;
inline boolean is_bound() const { return referred_function != NULL; }
inline boolean is_value() const { return referred_function != NULL; }
inline void clean_up() { referred_function = NULL; }
inline void must_bound(const char *err_msg) const
{ if (referred_function == NULL) TTCN_error("%s", err_msg); }

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);
};

extern boolean operator==(MGCPCreateCallback::function_pointer value, const MGCPCreateCallback& other_value);
inline boolean operator!=(MGCPCreateCallback::function_pointer value, const MGCPCreateCallback& other_value)
{ return !(value == other_value); } 

class MGCPCreateCallback_template : public Base_Template {
union {
MGCPCreateCallback::function_pointer single_value;
struct {
unsigned int n_values;
MGCPCreateCallback_template *list_value;
} value_list;
};

  void copy_template(const MGCPCreateCallback_template& other_value);
public:
MGCPCreateCallback_template();
MGCPCreateCallback_template(template_sel other_value);
MGCPCreateCallback_template(MGCPCreateCallback::function_pointer other_value);
MGCPCreateCallback_template(const MGCPCreateCallback& other_value);
MGCPCreateCallback_template(const OPTIONAL<MGCPCreateCallback>& other_value);
MGCPCreateCallback_template(const MGCPCreateCallback_template& other_value);
~MGCPCreateCallback_template();
void clean_up();
MGCPCreateCallback_template& operator=(template_sel other_value);
MGCPCreateCallback_template& operator=(MGCPCreateCallback::function_pointer other_value);
MGCPCreateCallback_template& operator=(const MGCPCreateCallback& other_value);
MGCPCreateCallback_template& operator=(const OPTIONAL<MGCPCreateCallback>& other_value);
MGCPCreateCallback_template& operator=(const MGCPCreateCallback_template& other_value);
boolean match(MGCPCreateCallback::function_pointer other_value, boolean legacy = FALSE) const;
boolean match(const MGCPCreateCallback& other_value, boolean legacy = FALSE) const;
MGCPCreateCallback valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
MGCPCreateCallback_template& list_item(unsigned int list_index) const;
void log() const;
void log_match(const MGCPCreateCallback& 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 MGCPUnitdataCallback : public Base_Type {
public:
typedef MGCP__Types::MgcpMessage_template (*function_pointer)(const MGCP__Types::MgcpMessage& msg);
typedef void (*start_pointer)(const COMPONENT& component_reference, const MGCP__Types::MgcpMessage& msg);
private:
friend class MGCPUnitdataCallback_template;
friend boolean operator==(MGCPUnitdataCallback::function_pointer value, const MGCPUnitdataCallback& other_value);
function_pointer referred_function;
public:
MGCPUnitdataCallback();
MGCPUnitdataCallback(function_pointer other_value);
MGCPUnitdataCallback(const MGCPUnitdataCallback& other_value);
MGCPUnitdataCallback& operator=(function_pointer other_value);
MGCPUnitdataCallback& operator=(const MGCPUnitdataCallback& other_value);
boolean operator==(function_pointer other_value) const;
boolean operator==(const MGCPUnitdataCallback& other_value) const;
inline boolean operator!=(function_pointer other_value) const
{ return !(*this == other_value); }
inline boolean operator!=(const MGCPUnitdataCallback& other_value) const
{ return !(*this == other_value); }

MGCP__Types::MgcpMessage_template invoke(const MGCP__Types::MgcpMessage& msg) const;
void start(const COMPONENT& component_reference, const MGCP__Types::MgcpMessage& msg) const;
inline boolean is_bound() const { return referred_function != NULL; }
inline boolean is_value() const { return referred_function != NULL; }
inline void clean_up() { referred_function = NULL; }
inline void must_bound(const char *err_msg) const
{ if (referred_function == NULL) TTCN_error("%s", err_msg); }

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);
};

extern boolean operator==(MGCPUnitdataCallback::function_pointer value, const MGCPUnitdataCallback& other_value);
inline boolean operator!=(MGCPUnitdataCallback::function_pointer value, const MGCPUnitdataCallback& other_value)
{ return !(value == other_value); } 

class MGCPUnitdataCallback_template : public Base_Template {
union {
MGCPUnitdataCallback::function_pointer single_value;
struct {
unsigned int n_values;
MGCPUnitdataCallback_template *list_value;
} value_list;
};

  void copy_template(const MGCPUnitdataCallback_template& other_value);
public:
MGCPUnitdataCallback_template();
MGCPUnitdataCallback_template(template_sel other_value);
MGCPUnitdataCallback_template(MGCPUnitdataCallback::function_pointer other_value);
MGCPUnitdataCallback_template(const MGCPUnitdataCallback& other_value);
MGCPUnitdataCallback_template(const OPTIONAL<MGCPUnitdataCallback>& other_value);
MGCPUnitdataCallback_template(const MGCPUnitdataCallback_template& other_value);
~MGCPUnitdataCallback_template();
void clean_up();
MGCPUnitdataCallback_template& operator=(template_sel other_value);
MGCPUnitdataCallback_template& operator=(MGCPUnitdataCallback::function_pointer other_value);
MGCPUnitdataCallback_template& operator=(const MGCPUnitdataCallback& other_value);
MGCPUnitdataCallback_template& operator=(const OPTIONAL<MGCPUnitdataCallback>& other_value);
MGCPUnitdataCallback_template& operator=(const MGCPUnitdataCallback_template& other_value);
boolean match(MGCPUnitdataCallback::function_pointer other_value, boolean legacy = FALSE) const;
boolean match(const MGCPUnitdataCallback& other_value, boolean legacy = FALSE) const;
MGCPUnitdataCallback valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
MGCPUnitdataCallback_template& list_item(unsigned int list_index) const;
void log() const;
void log_match(const MGCPUnitdataCallback& 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 MGCPOps {
  MGCPCreateCallback field_create__cb;
  MGCPUnitdataCallback field_unitdata__cb;
public:
  MGCPOps();
  MGCPOps(const MGCPCreateCallback& par_create__cb,
    const MGCPUnitdataCallback& par_unitdata__cb);
  MGCPOps(const MGCPOps& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  MGCPOps& operator=(const MGCPOps& other_value);
  boolean operator==(const MGCPOps& other_value) const;
  inline boolean operator!=(const MGCPOps& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline MGCPCreateCallback& create__cb()
    {return field_create__cb;}
  inline const MGCPCreateCallback& create__cb() const
    {return field_create__cb;}
  inline MGCPUnitdataCallback& unitdata__cb()
    {return field_unitdata__cb;}
  inline const MGCPUnitdataCallback& unitdata__cb() const
    {return field_unitdata__cb;}
  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 MGCPOps_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
MGCPOps_template *list_value;
} value_list;
struct {
MGCPOps_template* precondition;
MGCPOps_template* implied_template;
} implication_;
dynmatch_struct<MGCPOps>* dyn_match;
};

void set_specific();
void copy_value(const MGCPOps& other_value);
void copy_template(const MGCPOps_template& other_value);

public:
MGCPOps_template();
MGCPOps_template(template_sel other_value);
MGCPOps_template(const MGCPOps& other_value);
MGCPOps_template(const OPTIONAL<MGCPOps>& other_value);
MGCPOps_template(MGCPOps_template* p_precondition, MGCPOps_template* p_implied_template);
MGCPOps_template(Dynamic_Match_Interface<MGCPOps>* p_dyn_match);
MGCPOps_template(const MGCPOps_template& other_value);
~MGCPOps_template();
MGCPOps_template& operator=(template_sel other_value);
MGCPOps_template& operator=(const MGCPOps& other_value);
MGCPOps_template& operator=(const OPTIONAL<MGCPOps>& other_value);
MGCPOps_template& operator=(const MGCPOps_template& other_value);
boolean match(const MGCPOps& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
MGCPOps valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
MGCPOps_template& list_item(unsigned int list_index) const;
MGCPCreateCallback_template& create__cb();
const MGCPCreateCallback_template& create__cb() const;
MGCPUnitdataCallback_template& unitdata__cb();
const MGCPUnitdataCallback_template& unitdata__cb() const;
int size_of() const;
void log() const;
void log_match(const MGCPOps& 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 MGCPEM__register_call {
ExpectCriteria param_cmd;
COMPONENT param_hdlr;
public:
inline ExpectCriteria& cmd() { return param_cmd; }
inline const ExpectCriteria& cmd() const { return param_cmd; }
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 MGCPEM__register_call_redirect {
ExpectCriteria *ptr_cmd;
COMPONENT *ptr_hdlr;
public:
MGCPEM__register_call_redirect(ExpectCriteria *par_cmd = NULL, COMPONENT *par_hdlr = NULL)
 : ptr_cmd(par_cmd), ptr_hdlr(par_hdlr) { }
virtual ~MGCPEM__register_call_redirect() { }
virtual void set_parameters(const MGCPEM__register_call& call_par) const;
};

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

class MGCPEM__register_reply_redirect {
public:
inline void set_parameters(const MGCPEM__register_reply&) const {}
};

class MGCPEM__register_template {
ExpectCriteria_template param_cmd;
COMPONENT_template param_hdlr;
public:
MGCPEM__register_template();
inline ExpectCriteria_template& cmd() { return param_cmd; }
inline const ExpectCriteria_template& cmd() const { return param_cmd; }
inline COMPONENT_template& hdlr() { return param_hdlr; }
inline const COMPONENT_template& hdlr() const { return param_hdlr; }
MGCPEM__register_call create_call() const;
inline MGCPEM__register_reply create_reply() const { return MGCPEM__register_reply(); }
boolean match_call(const MGCPEM__register_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const MGCPEM__register_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const MGCPEM__register_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const MGCPEM__register_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class MGCPEM__delete__ep_call {
CHARSTRING param_ep;
COMPONENT param_hdlr;
public:
inline CHARSTRING& ep() { return param_ep; }
inline const CHARSTRING& ep() const { return param_ep; }
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 MGCPEM__delete__ep_call_redirect {
CHARSTRING *ptr_ep;
COMPONENT *ptr_hdlr;
public:
MGCPEM__delete__ep_call_redirect(CHARSTRING *par_ep = NULL, COMPONENT *par_hdlr = NULL)
 : ptr_ep(par_ep), ptr_hdlr(par_hdlr) { }
virtual ~MGCPEM__delete__ep_call_redirect() { }
virtual void set_parameters(const MGCPEM__delete__ep_call& call_par) const;
};

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

class MGCPEM__delete__ep_reply_redirect {
public:
inline void set_parameters(const MGCPEM__delete__ep_reply&) const {}
};

class MGCPEM__delete__ep_template {
CHARSTRING_template param_ep;
COMPONENT_template param_hdlr;
public:
MGCPEM__delete__ep_template();
inline CHARSTRING_template& ep() { return param_ep; }
inline const CHARSTRING_template& ep() const { return param_ep; }
inline COMPONENT_template& hdlr() { return param_hdlr; }
inline const COMPONENT_template& hdlr() const { return param_hdlr; }
MGCPEM__delete__ep_call create_call() const;
inline MGCPEM__delete__ep_reply create_reply() const { return MGCPEM__delete__ep_reply(); }
boolean match_call(const MGCPEM__delete__ep_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const MGCPEM__delete__ep_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const MGCPEM__delete__ep_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const MGCPEM__delete__ep_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class MGCPEM__change__connhdlr_call {
CHARSTRING param_ep;
COMPONENT param_hdlr;
public:
inline CHARSTRING& ep() { return param_ep; }
inline const CHARSTRING& ep() const { return param_ep; }
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 MGCPEM__change__connhdlr_call_redirect {
CHARSTRING *ptr_ep;
COMPONENT *ptr_hdlr;
public:
MGCPEM__change__connhdlr_call_redirect(CHARSTRING *par_ep = NULL, COMPONENT *par_hdlr = NULL)
 : ptr_ep(par_ep), ptr_hdlr(par_hdlr) { }
virtual ~MGCPEM__change__connhdlr_call_redirect() { }
virtual void set_parameters(const MGCPEM__change__connhdlr_call& call_par) const;
};

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

class MGCPEM__change__connhdlr_reply_redirect {
public:
inline void set_parameters(const MGCPEM__change__connhdlr_reply&) const {}
};

class MGCPEM__change__connhdlr_template {
CHARSTRING_template param_ep;
COMPONENT_template param_hdlr;
public:
MGCPEM__change__connhdlr_template();
inline CHARSTRING_template& ep() { return param_ep; }
inline const CHARSTRING_template& ep() const { return param_ep; }
inline COMPONENT_template& hdlr() { return param_hdlr; }
inline const COMPONENT_template& hdlr() const { return param_hdlr; }
MGCPEM__change__connhdlr_call create_call() const;
inline MGCPEM__change__connhdlr_reply create_reply() const { return MGCPEM__change__connhdlr_reply(); }
boolean match_call(const MGCPEM__change__connhdlr_call& match_value, boolean legacy = FALSE) const;
inline boolean match_reply(const MGCPEM__change__connhdlr_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const MGCPEM__change__connhdlr_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const MGCPEM__change__connhdlr_reply& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class MGCPEM__PROC__PT : public PORT {
enum proc_selection { CALL_0, CALL_1, CALL_2, REPLY_0, REPLY_1, REPLY_2 };
struct proc_queue_item {
proc_selection item_selection;
union {
MGCPEM__register_call *call_0;
MGCPEM__delete__ep_call *call_1;
MGCPEM__change__connhdlr_call *call_2;
MGCPEM__register_reply *reply_0;
MGCPEM__delete__ep_reply *reply_1;
MGCPEM__change__connhdlr_reply *reply_2;
};
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:
MGCPEM__PROC__PT(const char *par_port_name = NULL);
~MGCPEM__PROC__PT();
void call(const MGCPEM__register_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const MGCPEM__register_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const MGCPEM__register_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const MGCPEM__delete__ep_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const MGCPEM__delete__ep_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const MGCPEM__delete__ep_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void call(const MGCPEM__change__connhdlr_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const MGCPEM__change__connhdlr_template& call_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void call(const MGCPEM__change__connhdlr_template& call_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const MGCPEM__register_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const MGCPEM__register_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const MGCPEM__register_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const MGCPEM__delete__ep_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const MGCPEM__delete__ep_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const MGCPEM__delete__ep_template& reply_template, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void reply(const MGCPEM__change__connhdlr_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const MGCPEM__change__connhdlr_template& reply_template, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void reply(const MGCPEM__change__connhdlr_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 MGCPEM__register_template& getcall_template, const COMPONENT_template& sender_template, const MGCPEM__register_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const MGCPEM__register_template& getcall_template, const COMPONENT_template& sender_template, const MGCPEM__register_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const MGCPEM__delete__ep_template& getcall_template, const COMPONENT_template& sender_template, const MGCPEM__delete__ep_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const MGCPEM__delete__ep_template& getcall_template, const COMPONENT_template& sender_template, const MGCPEM__delete__ep_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const MGCPEM__change__connhdlr_template& getcall_template, const COMPONENT_template& sender_template, const MGCPEM__change__connhdlr_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const MGCPEM__change__connhdlr_template& getcall_template, const COMPONENT_template& sender_template, const MGCPEM__change__connhdlr_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 MGCPEM__register_template& getreply_template, const COMPONENT_template& sender_template, const MGCPEM__register_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const MGCPEM__register_template& getreply_template, const COMPONENT_template& sender_template, const MGCPEM__register_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const MGCPEM__delete__ep_template& getreply_template, const COMPONENT_template& sender_template, const MGCPEM__delete__ep_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const MGCPEM__delete__ep_template& getreply_template, const COMPONENT_template& sender_template, const MGCPEM__delete__ep_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const MGCPEM__change__connhdlr_template& getreply_template, const COMPONENT_template& sender_template, const MGCPEM__change__connhdlr_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const MGCPEM__change__connhdlr_template& getreply_template, const COMPONENT_template& sender_template, const MGCPEM__change__connhdlr_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_call(const MGCPEM__register_call& incoming_par, component sender_component);
void incoming_call(const MGCPEM__delete__ep_call& incoming_par, component sender_component);
void incoming_call(const MGCPEM__change__connhdlr_call& incoming_par, component sender_component);
void incoming_reply(const MGCPEM__register_reply& incoming_par, component sender_component);
void incoming_reply(const MGCPEM__delete__ep_reply& incoming_par, component sender_component);
void incoming_reply(const MGCPEM__change__connhdlr_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);
};


/* Function prototypes */

extern MGCP__CodecPort::MGCP__RecvFrom_template tr__MGCP__RecvFrom__R(const MGCP__Types::MgcpMessage_template& msg);
extern void start_tr__MGCP__RecvFrom__R(const COMPONENT& component_reference, const MGCP__Types::MgcpMessage_template& msg);
extern BOOLEAN f__ep__known(const CHARSTRING& ep);
extern void start_f__ep__known(const COMPONENT& component_reference, const CHARSTRING& ep);
extern BOOLEAN f__comp__known(const COMPONENT& client);
extern void start_f__comp__known(const COMPONENT& component_reference, const COMPONENT& client);
extern COMPONENT f__comp__by__ep(const CHARSTRING& ep);
extern void start_f__comp__by__ep(const COMPONENT& component_reference, const CHARSTRING& ep);
extern CHARSTRING f__ep__by__comp(const COMPONENT& client);
extern void start_f__ep__by__comp(const COMPONENT& component_reference, const COMPONENT& client);
extern void f__ep__table__add(const COMPONENT& comp__ref, const CHARSTRING& ep);
extern void start_f__ep__table__add(const COMPONENT& component_reference, const COMPONENT& comp__ref, const CHARSTRING& ep);
extern void f__ep__table__del(const COMPONENT& comp__ref, const CHARSTRING& ep);
extern void start_f__ep__table__del(const COMPONENT& component_reference, const COMPONENT& comp__ref, const CHARSTRING& ep);
extern void f__ep__table__change__connhdlr(const COMPONENT& comp__ref, const CHARSTRING& ep);
extern void start_f__ep__table__change__connhdlr(const COMPONENT& component_reference, const COMPONENT& comp__ref, const CHARSTRING& ep);
extern BOOLEAN f__trans__id__was__pending(const CHARSTRING& trans__id);
extern void start_f__trans__id__was__pending(const COMPONENT& component_reference, const CHARSTRING& trans__id);
extern CHARSTRING f__mgcp__ep(const MGCP__Types::MgcpMessage& msg);
extern void f__ep__table__init();
extern void start_f__ep__table__init(const COMPONENT& component_reference);
extern void f__forward__to__client(const MGCP__CodecPort::MGCP__RecvFrom& mrf, const COMPONENT& vc__conn);
extern void start_f__forward__to__client(const COMPONENT& component_reference, const MGCP__CodecPort::MGCP__RecvFrom& mrf, const COMPONENT& vc__conn);
extern void main_(const MGCPOps& ops, const MGCP__conn__parameters& p, const CHARSTRING& id);
extern void start_main_(const COMPONENT& component_reference, const MGCPOps& ops, const MGCP__conn__parameters& p, const CHARSTRING& id);
extern MGCP__Types::MgcpCommand_template f__get__mgcp__by__crit(const ExpectCriteria& crit);
extern COMPONENT ExpectedCreateCallback(const MGCP__Types::MgcpCommand& cmd, const CHARSTRING& );
extern void start_ExpectedCreateCallback(const COMPONENT& component_reference, const MGCP__Types::MgcpCommand& cmd, const CHARSTRING& id);
extern void f__create__expect(const ExpectCriteria& crit, const COMPONENT& hdlr);
extern void start_f__create__expect(const COMPONENT& component_reference, const ExpectCriteria& crit, const COMPONENT& hdlr);
extern void f__create__mgcp__expect(const ExpectCriteria& dest__number);
extern void start_f__create__mgcp__expect(const COMPONENT& component_reference, const ExpectCriteria& dest__number);
extern void f__create__mgcp__delete__ep(const CHARSTRING& ep);
extern void start_f__create__mgcp__delete__ep(const COMPONENT& component_reference, const CHARSTRING& ep);
extern void f__mgcp__change__connhdlr(const CHARSTRING& ep);
extern void start_f__mgcp__change__connhdlr(const COMPONENT& component_reference, const CHARSTRING& ep);
extern void f__expect__table__init();
extern void start_f__expect__table__init(const COMPONENT& component_reference);
extern MGCP__Types::MgcpMessage_template DummyUnitdataCallback(const MGCP__Types::MgcpMessage& msg);
extern void start_DummyUnitdataCallback(const COMPONENT& component_reference, const MGCP__Types::MgcpMessage& msg);
extern CHARSTRING f__encoding__name__from__pt(const MGCP__Types::SDP__FIELD__PayloadType& pt);
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& MGCP__ConnHdlr_descr_;
extern MGCP__Conn__PT MGCP__ConnHdlr_component_MGCP;
extern MGCP__Conn__Multi__PT MGCP__ConnHdlr_component_MGCP__MULTI;
extern MGCPEM__PROC__PT MGCP__ConnHdlr_component_MGCP__PROC;
extern const TTCN_Typedescriptor_t EndpointData_descr_;
extern const XERdescriptor_t EndpointData_endpoint_xer_;
extern const TTCN_Typedescriptor_t EndpointData_endpoint_descr_;
extern UNIVERSAL_CHARSTRING EndpointData_endpoint_default_coding;
extern const TTCN_Typedescriptor_t MgcpTransIds_descr_;
extern const XERdescriptor_t MgcpTransIds_0_xer_;
extern const TTCN_Typedescriptor_t MgcpTransIds_0_descr_;
extern UNIVERSAL_CHARSTRING MgcpTransIds_0_default_coding;
extern const TTCN_Typedescriptor_t& MGCP__Emulation__CT_descr_;
extern MGCP__CodecPort::MGCP__CODEC__PT MGCP__Emulation__CT_component_MGCP;
extern MGCP__Conn__PT MGCP__Emulation__CT_component_MGCP__CLIENT;
extern MGCP__Conn__Multi__PT MGCP__Emulation__CT_component_MGCP__CLIENT__MULTI;
extern VALUE_ARRAY<EndpointData, 16, 0> MGCP__Emulation__CT_component_MgcpEndpointTable;
extern MgcpTransIds MGCP__Emulation__CT_component_MgcpPendingTrans;
extern const TTCN_Typedescriptor_t ExpectData_descr_;
extern const TTCN_Typedescriptor_t ExpectCriteria_descr_;
extern const XERdescriptor_t ExpectCriteria_connid_xer_;
extern const TTCN_Typedescriptor_t ExpectCriteria_connid_descr_;
extern const XERdescriptor_t ExpectCriteria_endpoint_xer_;
extern const TTCN_Typedescriptor_t ExpectCriteria_endpoint_descr_;
extern UNIVERSAL_CHARSTRING ExpectCriteria_endpoint_default_coding;
extern const XERdescriptor_t ExpectCriteria_transid_xer_;
extern const TTCN_Typedescriptor_t ExpectCriteria_transid_descr_;
extern UNIVERSAL_CHARSTRING ExpectCriteria_transid_default_coding;
extern VALUE_ARRAY<ExpectData, 8, 0> MGCP__Emulation__CT_component_MgcpExpectTable;
extern MGCPEM__PROC__PT MGCP__Emulation__CT_component_MGCP__PROC;
extern CHARSTRING MGCP__Emulation__CT_component_g__mgcp__id;
extern INTEGER MGCP__Emulation__CT_component_g__mgcp__conn__id;
extern const XERdescriptor_t MGCP__conn__parameters_callagent__ip_xer_;
extern const TTCN_Typedescriptor_t MGCP__conn__parameters_callagent__ip_descr_;
extern const XERdescriptor_t MGCP__conn__parameters_callagent__udp__port_xer_;
extern const TTCN_OERdescriptor_t MGCP__conn__parameters_callagent__udp__port_oer_;
extern const TTCN_Typedescriptor_t MGCP__conn__parameters_callagent__udp__port_descr_;
extern const XERdescriptor_t MGCP__conn__parameters_mgw__ip_xer_;
extern const TTCN_Typedescriptor_t MGCP__conn__parameters_mgw__ip_descr_;
extern const XERdescriptor_t MGCP__conn__parameters_mgw__udp__port_xer_;
extern const TTCN_OERdescriptor_t MGCP__conn__parameters_mgw__udp__port_oer_;
extern const TTCN_Typedescriptor_t MGCP__conn__parameters_mgw__udp__port_descr_;
extern const XERdescriptor_t MGCP__conn__parameters_multi__conn__mode_xer_;
extern const TTCN_OERdescriptor_t MGCP__conn__parameters_multi__conn__mode_oer_;
extern const TTCN_Typedescriptor_t MGCP__conn__parameters_multi__conn__mode_descr_;
extern const TTCN_Typedescriptor_t MGCP__conn__parameters_descr_;
extern MGCP__conn__parameters MGCP__Emulation__CT_component_g__pars;
extern const TTCN_Typedescriptor_t MGCPCreateCallback_descr_;
extern const TTCN_Typedescriptor_t MGCPUnitdataCallback_descr_;
extern const TTCN_Typedescriptor_t MGCPOps_descr_;
extern const CHARSTRING cs_13,
cs_11,
cs_12,
cs_4,
cs_3,
cs_7,
cs_9,
cs_10,
cs_1,
cs_0,
cs_5,
cs_8,
cs_6,
cs_2;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif