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

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

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

#ifndef NS__Emulation_HH
#define NS__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 "Osmocom_Gb_Types.hh"
#include "NS_Provider_IPL4.hh"
#include "NS_Provider_FR.hh"
#include "IPL4asp_Types.hh"

#if TTCN3_VERSION != 90000
#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 NS__Emulation_HH
#endif

namespace NS__Emulation {

/* Forward declarations of classes */

class NsUnitdataRequest;
class NsUnitdataRequest_template;
class NsUnitdataIndication;
class NsUnitdataIndication_template;
class NsvcState;
class NsvcState_template;
class NsStatusIndication;
class NsStatusIndication_template;
class NS__SP__PT;
class NS__PT;
class NS__CTRL__SP__PT;
class NS__CTRL__PT;
class NsDisableVcRequest;
class NsDisableVcRequest_template;
class NsEnableVcRequest;
class NsEnableVcRequest_template;
class NS__Provider__LinkStatus;
class NS__Provider__LinkStatus_template;
class NS__Provider__Evt;
class NS__Provider__Evt_template;
class NS__PROVIDER__PT;
class NSVCConfigurationIP;
class NSVCConfigurationIP_template;
class NSVCConfigurationFR;
class NSVCConfigurationFR_template;
class NSVCConfigurationP;
class NSVCConfigurationP_template;
class NSVCConfiguration;
class NSVCConfiguration_template;
class NSVCConfigurations;
class NSVCConfigurations_template;
class NSConfiguration;
class NSConfiguration_template;
class IpEndpointTable;
class IpEndpointTable_template;
class IpEndpointTableEntry;
class IpEndpointTableEntry_template;
class NsvcTable;
class NsvcTable_template;
class NsvcTableEntry;
class NsvcTableEntry_template;
class NSint__SP__PT;
class NSint__PT;
class SnsIndication;
class SnsIndication_template;
class SnsRequest;
class SnsRequest_template;
class NsCtrlRequest;
class NsCtrlRequest_template;

} /* end of namespace */

#ifndef NS__Emulation_HH
#define NS__Emulation_HH

namespace NS__Emulation {

/* Type definitions */

typedef COMPONENT NS__Provider__CT;
typedef COMPONENT_template NS__Provider__CT_template;
typedef COMPONENT NS__CT;
typedef COMPONENT_template NS__CT_template;
typedef COMPONENT NSVC__CT;
typedef COMPONENT_template NSVC__CT_template;

/* Class definitions */

class NsUnitdataRequest {
  INTEGER field_bvci;
  INTEGER field_nsei;
  INTEGER field_lsp;
  OPTIONAL< OCTETSTRING > field_sdu;
  OPTIONAL< BSSGP__Types::PDU__BSSGP > field_bssgp;
public:
  NsUnitdataRequest();
  NsUnitdataRequest(const INTEGER& par_bvci,
    const INTEGER& par_nsei,
    const INTEGER& par_lsp,
    const OPTIONAL< OCTETSTRING >& par_sdu,
    const OPTIONAL< BSSGP__Types::PDU__BSSGP >& par_bssgp);
  NsUnitdataRequest(const NsUnitdataRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  NsUnitdataRequest& operator=(const NsUnitdataRequest& other_value);
  boolean operator==(const NsUnitdataRequest& other_value) const;
  inline boolean operator!=(const NsUnitdataRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& bvci()
    {return field_bvci;}
  inline const INTEGER& bvci() const
    {return field_bvci;}
  inline INTEGER& nsei()
    {return field_nsei;}
  inline const INTEGER& nsei() const
    {return field_nsei;}
  inline INTEGER& lsp()
    {return field_lsp;}
  inline const INTEGER& lsp() const
    {return field_lsp;}
  inline OPTIONAL< OCTETSTRING >& sdu()
    {return field_sdu;}
  inline const OPTIONAL< OCTETSTRING >& sdu() const
    {return field_sdu;}
  inline OPTIONAL< BSSGP__Types::PDU__BSSGP >& bssgp()
    {return field_bssgp;}
  inline const OPTIONAL< BSSGP__Types::PDU__BSSGP >& bssgp() const
    {return field_bssgp;}
  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 NsUnitdataRequest_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
NsUnitdataRequest_template *list_value;
} value_list;
struct {
NsUnitdataRequest_template* precondition;
NsUnitdataRequest_template* implied_template;
} implication_;
dynmatch_struct<NsUnitdataRequest>* dyn_match;
};

void set_specific();
void copy_value(const NsUnitdataRequest& other_value);
void copy_template(const NsUnitdataRequest_template& other_value);

public:
NsUnitdataRequest_template();
NsUnitdataRequest_template(template_sel other_value);
NsUnitdataRequest_template(const NsUnitdataRequest& other_value);
NsUnitdataRequest_template(const OPTIONAL<NsUnitdataRequest>& other_value);
NsUnitdataRequest_template(NsUnitdataRequest_template* p_precondition, NsUnitdataRequest_template* p_implied_template);
NsUnitdataRequest_template(Dynamic_Match_Interface<NsUnitdataRequest>* p_dyn_match);
NsUnitdataRequest_template(const NsUnitdataRequest_template& other_value);
~NsUnitdataRequest_template();
NsUnitdataRequest_template& operator=(template_sel other_value);
NsUnitdataRequest_template& operator=(const NsUnitdataRequest& other_value);
NsUnitdataRequest_template& operator=(const OPTIONAL<NsUnitdataRequest>& other_value);
NsUnitdataRequest_template& operator=(const NsUnitdataRequest_template& other_value);
boolean match(const NsUnitdataRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
NsUnitdataRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NsUnitdataRequest_template& list_item(unsigned int list_index) const;
INTEGER_template& bvci();
const INTEGER_template& bvci() const;
INTEGER_template& nsei();
const INTEGER_template& nsei() const;
INTEGER_template& lsp();
const INTEGER_template& lsp() const;
OCTETSTRING_template& sdu();
const OCTETSTRING_template& sdu() const;
BSSGP__Types::PDU__BSSGP_template& bssgp();
const BSSGP__Types::PDU__BSSGP_template& bssgp() const;
int size_of() const;
void log() const;
void log_match(const NsUnitdataRequest& match_value, boolean legacy = FALSE) const;
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 NsUnitdataIndication {
  INTEGER field_bvci;
  INTEGER field_nsei;
  INTEGER field_nsvci;
  OPTIONAL< OCTETSTRING > field_sdu;
  OPTIONAL< BSSGP__Types::PDU__BSSGP > field_bssgp;
public:
  NsUnitdataIndication();
  NsUnitdataIndication(const INTEGER& par_bvci,
    const INTEGER& par_nsei,
    const INTEGER& par_nsvci,
    const OPTIONAL< OCTETSTRING >& par_sdu,
    const OPTIONAL< BSSGP__Types::PDU__BSSGP >& par_bssgp);
  NsUnitdataIndication(const NsUnitdataIndication& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  NsUnitdataIndication& operator=(const NsUnitdataIndication& other_value);
  boolean operator==(const NsUnitdataIndication& other_value) const;
  inline boolean operator!=(const NsUnitdataIndication& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& bvci()
    {return field_bvci;}
  inline const INTEGER& bvci() const
    {return field_bvci;}
  inline INTEGER& nsei()
    {return field_nsei;}
  inline const INTEGER& nsei() const
    {return field_nsei;}
  inline INTEGER& nsvci()
    {return field_nsvci;}
  inline const INTEGER& nsvci() const
    {return field_nsvci;}
  inline OPTIONAL< OCTETSTRING >& sdu()
    {return field_sdu;}
  inline const OPTIONAL< OCTETSTRING >& sdu() const
    {return field_sdu;}
  inline OPTIONAL< BSSGP__Types::PDU__BSSGP >& bssgp()
    {return field_bssgp;}
  inline const OPTIONAL< BSSGP__Types::PDU__BSSGP >& bssgp() const
    {return field_bssgp;}
  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 NsUnitdataIndication_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
NsUnitdataIndication_template *list_value;
} value_list;
struct {
NsUnitdataIndication_template* precondition;
NsUnitdataIndication_template* implied_template;
} implication_;
dynmatch_struct<NsUnitdataIndication>* dyn_match;
};

void set_specific();
void copy_value(const NsUnitdataIndication& other_value);
void copy_template(const NsUnitdataIndication_template& other_value);

public:
NsUnitdataIndication_template();
NsUnitdataIndication_template(template_sel other_value);
NsUnitdataIndication_template(const NsUnitdataIndication& other_value);
NsUnitdataIndication_template(const OPTIONAL<NsUnitdataIndication>& other_value);
NsUnitdataIndication_template(NsUnitdataIndication_template* p_precondition, NsUnitdataIndication_template* p_implied_template);
NsUnitdataIndication_template(Dynamic_Match_Interface<NsUnitdataIndication>* p_dyn_match);
NsUnitdataIndication_template(const NsUnitdataIndication_template& other_value);
~NsUnitdataIndication_template();
NsUnitdataIndication_template& operator=(template_sel other_value);
NsUnitdataIndication_template& operator=(const NsUnitdataIndication& other_value);
NsUnitdataIndication_template& operator=(const OPTIONAL<NsUnitdataIndication>& other_value);
NsUnitdataIndication_template& operator=(const NsUnitdataIndication_template& other_value);
boolean match(const NsUnitdataIndication& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
NsUnitdataIndication valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NsUnitdataIndication_template& list_item(unsigned int list_index) const;
INTEGER_template& bvci();
const INTEGER_template& bvci() const;
INTEGER_template& nsei();
const INTEGER_template& nsei() const;
INTEGER_template& nsvci();
const INTEGER_template& nsvci() const;
OCTETSTRING_template& sdu();
const OCTETSTRING_template& sdu() const;
BSSGP__Types::PDU__BSSGP_template& bssgp();
const BSSGP__Types::PDU__BSSGP_template& bssgp() const;
int size_of() const;
void log() const;
void log_match(const NsUnitdataIndication& match_value, boolean legacy = FALSE) const;
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 NsvcState : public Base_Type { // enum
friend class NsvcState_template;
public:
enum enum_type { NSVC__S__DISABLED = 0, NSVC__S__DEAD__BLOCKED = 1, NSVC__S__WAIT__RESET = 2, NSVC__S__ALIVE__BLOCKED = 3, NSVC__S__ALIVE__UNBLOCKED = 4, UNKNOWN_VALUE = 5, UNBOUND_VALUE = 6 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const NsvcState& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const NsvcState& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const NsvcState& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const NsvcState& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const NsvcState& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const NsvcState& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const NsvcState& 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 NsvcState_template : public Base_Template {
union {
NsvcState::enum_type single_value;
struct {
unsigned int n_values;
NsvcState_template *list_value;
} value_list;
struct {
NsvcState_template* precondition;
NsvcState_template* implied_template;
} implication_;
dynmatch_struct<NsvcState>* dyn_match;
};

void copy_template(const NsvcState_template& other_value);

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

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

boolean match(NsvcState::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const NsvcState& other_value, boolean legacy = FALSE) const;
NsvcState::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NsvcState_template& list_item(unsigned int list_index);
void log() const;
void log_match(const NsvcState& 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 NsStatusIndication {
  INTEGER field_nsei;
  INTEGER field_nsvci;
  NsvcState field_old__state;
  NsvcState field_new__state;
  BOOLEAN field_first__or__last;
public:
  NsStatusIndication();
  NsStatusIndication(const INTEGER& par_nsei,
    const INTEGER& par_nsvci,
    const NsvcState& par_old__state,
    const NsvcState& par_new__state,
    const BOOLEAN& par_first__or__last);
  NsStatusIndication(const NsStatusIndication& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  NsStatusIndication& operator=(const NsStatusIndication& other_value);
  boolean operator==(const NsStatusIndication& other_value) const;
  inline boolean operator!=(const NsStatusIndication& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& nsei()
    {return field_nsei;}
  inline const INTEGER& nsei() const
    {return field_nsei;}
  inline INTEGER& nsvci()
    {return field_nsvci;}
  inline const INTEGER& nsvci() const
    {return field_nsvci;}
  inline NsvcState& old__state()
    {return field_old__state;}
  inline const NsvcState& old__state() const
    {return field_old__state;}
  inline NsvcState& new__state()
    {return field_new__state;}
  inline const NsvcState& new__state() const
    {return field_new__state;}
  inline BOOLEAN& first__or__last()
    {return field_first__or__last;}
  inline const BOOLEAN& first__or__last() const
    {return field_first__or__last;}
  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 NsStatusIndication_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
NsStatusIndication_template *list_value;
} value_list;
struct {
NsStatusIndication_template* precondition;
NsStatusIndication_template* implied_template;
} implication_;
dynmatch_struct<NsStatusIndication>* dyn_match;
};

void set_specific();
void copy_value(const NsStatusIndication& other_value);
void copy_template(const NsStatusIndication_template& other_value);

public:
NsStatusIndication_template();
NsStatusIndication_template(template_sel other_value);
NsStatusIndication_template(const NsStatusIndication& other_value);
NsStatusIndication_template(const OPTIONAL<NsStatusIndication>& other_value);
NsStatusIndication_template(NsStatusIndication_template* p_precondition, NsStatusIndication_template* p_implied_template);
NsStatusIndication_template(Dynamic_Match_Interface<NsStatusIndication>* p_dyn_match);
NsStatusIndication_template(const NsStatusIndication_template& other_value);
~NsStatusIndication_template();
NsStatusIndication_template& operator=(template_sel other_value);
NsStatusIndication_template& operator=(const NsStatusIndication& other_value);
NsStatusIndication_template& operator=(const OPTIONAL<NsStatusIndication>& other_value);
NsStatusIndication_template& operator=(const NsStatusIndication_template& other_value);
boolean match(const NsStatusIndication& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
NsStatusIndication valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NsStatusIndication_template& list_item(unsigned int list_index) const;
INTEGER_template& nsei();
const INTEGER_template& nsei() const;
INTEGER_template& nsvci();
const INTEGER_template& nsvci() const;
NsvcState_template& old__state();
const NsvcState_template& old__state() const;
NsvcState_template& new__state();
const NsvcState_template& new__state() const;
BOOLEAN_template& first__or__last();
const BOOLEAN_template& first__or__last() const;
int size_of() const;
void log() const;
void log_match(const NsStatusIndication& match_value, boolean legacy = FALSE) const;
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 NS__SP__PT : public PORT {
enum msg_selection { MESSAGE_0 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
NsUnitdataRequest *message_0;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
NS__SP__PT(const char *par_port_name = NULL);
~NS__SP__PT();
void send(const NsUnitdataIndication& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataIndication& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataIndication_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataIndication_template& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsStatusIndication& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsStatusIndication& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsStatusIndication_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsStatusIndication_template& send_par, 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 NsUnitdataRequest_template& value_template, NsUnitdataRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NsUnitdataRequest_template& value_template, NsUnitdataRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NsUnitdataRequest_template& value_template, NsUnitdataRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const NsUnitdataRequest& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class NS__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 {
Socket__API__Definitions::PortEvent *message_0;
NsStatusIndication *message_1;
NsUnitdataIndication *message_2;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
NS__PT(const char *par_port_name = NULL);
~NS__PT();
void send(const NsUnitdataRequest& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataRequest& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataRequest_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataRequest_template& send_par, 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 Socket__API__Definitions::PortEvent_template& value_template, Socket__API__Definitions::PortEvent *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const Socket__API__Definitions::PortEvent_template& value_template, Socket__API__Definitions::PortEvent *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const Socket__API__Definitions::PortEvent_template& value_template, Socket__API__Definitions::PortEvent *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const NsStatusIndication_template& value_template, NsStatusIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NsStatusIndication_template& value_template, NsStatusIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NsStatusIndication_template& value_template, NsStatusIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const NsUnitdataIndication_template& value_template, NsUnitdataIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NsUnitdataIndication_template& value_template, NsUnitdataIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NsUnitdataIndication_template& value_template, NsUnitdataIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const Socket__API__Definitions::PortEvent& incoming_par, component sender_component);
void incoming_message(const NsStatusIndication& incoming_par, component sender_component);
void incoming_message(const NsUnitdataIndication& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class NS__CTRL__SP__PT : public PORT {
enum msg_selection { MESSAGE_0, MESSAGE_1 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
NsDisableVcRequest *message_0;
NsEnableVcRequest *message_1;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
NS__CTRL__SP__PT(const char *par_port_name = NULL);
~NS__CTRL__SP__PT();
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 NsDisableVcRequest_template& value_template, NsDisableVcRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NsDisableVcRequest_template& value_template, NsDisableVcRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NsDisableVcRequest_template& value_template, NsDisableVcRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const NsEnableVcRequest_template& value_template, NsEnableVcRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NsEnableVcRequest_template& value_template, NsEnableVcRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NsEnableVcRequest_template& value_template, NsEnableVcRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const NsDisableVcRequest& incoming_par, component sender_component);
void incoming_message(const NsEnableVcRequest& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class NS__CTRL__PT : public PORT {
public:
NS__CTRL__PT(const char *par_port_name = NULL);
void send(const NsEnableVcRequest& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsEnableVcRequest& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsEnableVcRequest_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsEnableVcRequest_template& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsDisableVcRequest& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsDisableVcRequest& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsDisableVcRequest_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsDisableVcRequest_template& send_par, FLOAT* timestamp_redirect = NULL);
public:
private:
protected:
};

class NsDisableVcRequest {
  INTEGER field_nsvci;
public:
  NsDisableVcRequest();
  NsDisableVcRequest(const INTEGER& par_nsvci);
  NsDisableVcRequest(const NsDisableVcRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  NsDisableVcRequest& operator=(const NsDisableVcRequest& other_value);
  boolean operator==(const NsDisableVcRequest& other_value) const;
  inline boolean operator!=(const NsDisableVcRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& nsvci()
    {return field_nsvci;}
  inline const INTEGER& nsvci() const
    {return field_nsvci;}
  inline int size_of() const
    {return 1;}
  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 NsDisableVcRequest_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
NsDisableVcRequest_template *list_value;
} value_list;
struct {
NsDisableVcRequest_template* precondition;
NsDisableVcRequest_template* implied_template;
} implication_;
dynmatch_struct<NsDisableVcRequest>* dyn_match;
};

void set_specific();
void copy_value(const NsDisableVcRequest& other_value);
void copy_template(const NsDisableVcRequest_template& other_value);

public:
NsDisableVcRequest_template();
NsDisableVcRequest_template(template_sel other_value);
NsDisableVcRequest_template(const NsDisableVcRequest& other_value);
NsDisableVcRequest_template(const OPTIONAL<NsDisableVcRequest>& other_value);
NsDisableVcRequest_template(NsDisableVcRequest_template* p_precondition, NsDisableVcRequest_template* p_implied_template);
NsDisableVcRequest_template(Dynamic_Match_Interface<NsDisableVcRequest>* p_dyn_match);
NsDisableVcRequest_template(const NsDisableVcRequest_template& other_value);
~NsDisableVcRequest_template();
NsDisableVcRequest_template& operator=(template_sel other_value);
NsDisableVcRequest_template& operator=(const NsDisableVcRequest& other_value);
NsDisableVcRequest_template& operator=(const OPTIONAL<NsDisableVcRequest>& other_value);
NsDisableVcRequest_template& operator=(const NsDisableVcRequest_template& other_value);
boolean match(const NsDisableVcRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
NsDisableVcRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NsDisableVcRequest_template& list_item(unsigned int list_index) const;
INTEGER_template& nsvci();
const INTEGER_template& nsvci() const;
int size_of() const;
void log() const;
void log_match(const NsDisableVcRequest& match_value, boolean legacy = FALSE) const;
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 NsEnableVcRequest {
  INTEGER field_nsvci;
public:
  NsEnableVcRequest();
  NsEnableVcRequest(const INTEGER& par_nsvci);
  NsEnableVcRequest(const NsEnableVcRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  NsEnableVcRequest& operator=(const NsEnableVcRequest& other_value);
  boolean operator==(const NsEnableVcRequest& other_value) const;
  inline boolean operator!=(const NsEnableVcRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& nsvci()
    {return field_nsvci;}
  inline const INTEGER& nsvci() const
    {return field_nsvci;}
  inline int size_of() const
    {return 1;}
  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 NsEnableVcRequest_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
NsEnableVcRequest_template *list_value;
} value_list;
struct {
NsEnableVcRequest_template* precondition;
NsEnableVcRequest_template* implied_template;
} implication_;
dynmatch_struct<NsEnableVcRequest>* dyn_match;
};

void set_specific();
void copy_value(const NsEnableVcRequest& other_value);
void copy_template(const NsEnableVcRequest_template& other_value);

public:
NsEnableVcRequest_template();
NsEnableVcRequest_template(template_sel other_value);
NsEnableVcRequest_template(const NsEnableVcRequest& other_value);
NsEnableVcRequest_template(const OPTIONAL<NsEnableVcRequest>& other_value);
NsEnableVcRequest_template(NsEnableVcRequest_template* p_precondition, NsEnableVcRequest_template* p_implied_template);
NsEnableVcRequest_template(Dynamic_Match_Interface<NsEnableVcRequest>* p_dyn_match);
NsEnableVcRequest_template(const NsEnableVcRequest_template& other_value);
~NsEnableVcRequest_template();
NsEnableVcRequest_template& operator=(template_sel other_value);
NsEnableVcRequest_template& operator=(const NsEnableVcRequest& other_value);
NsEnableVcRequest_template& operator=(const OPTIONAL<NsEnableVcRequest>& other_value);
NsEnableVcRequest_template& operator=(const NsEnableVcRequest_template& other_value);
boolean match(const NsEnableVcRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
NsEnableVcRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NsEnableVcRequest_template& list_item(unsigned int list_index) const;
INTEGER_template& nsvci();
const INTEGER_template& nsvci() const;
int size_of() const;
void log() const;
void log_match(const NsEnableVcRequest& match_value, boolean legacy = FALSE) const;
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 NS__Provider__LinkStatus : public Base_Type { // enum
friend class NS__Provider__LinkStatus_template;
public:
enum enum_type { NS__PROV__LINK__STATUS__UP = 0, NS__PROV__LINK__STATUS__DOWN = 1, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const NS__Provider__LinkStatus& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const NS__Provider__LinkStatus& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const NS__Provider__LinkStatus& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const NS__Provider__LinkStatus& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const NS__Provider__LinkStatus& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const NS__Provider__LinkStatus& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const NS__Provider__LinkStatus& 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 NS__Provider__LinkStatus_template : public Base_Template {
union {
NS__Provider__LinkStatus::enum_type single_value;
struct {
unsigned int n_values;
NS__Provider__LinkStatus_template *list_value;
} value_list;
struct {
NS__Provider__LinkStatus_template* precondition;
NS__Provider__LinkStatus_template* implied_template;
} implication_;
dynmatch_struct<NS__Provider__LinkStatus>* dyn_match;
};

void copy_template(const NS__Provider__LinkStatus_template& other_value);

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

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

boolean match(NS__Provider__LinkStatus::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const NS__Provider__LinkStatus& other_value, boolean legacy = FALSE) const;
NS__Provider__LinkStatus::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NS__Provider__LinkStatus_template& list_item(unsigned int list_index);
void log() const;
void log_match(const NS__Provider__LinkStatus& 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 NS__Provider__Evt : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_link__status = 1 };
private:
union_selection_type union_selection;
union {
NS__Provider__LinkStatus *field_link__status;
};
void copy_value(const NS__Provider__Evt& other_value);

public:
NS__Provider__Evt();
NS__Provider__Evt(const NS__Provider__Evt& other_value);
~NS__Provider__Evt();
NS__Provider__Evt& operator=(const NS__Provider__Evt& other_value);
boolean operator==(const NS__Provider__Evt& other_value) const;
inline boolean operator!=(const NS__Provider__Evt& other_value) const { return !(*this == other_value); }
NS__Provider__LinkStatus& link__status();
const NS__Provider__LinkStatus& link__status() const;
inline union_selection_type get_selection() const { return union_selection; }
boolean ischosen(union_selection_type checked_selection) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class NS__Provider__Evt_template : public Base_Template {
union {
struct {
NS__Provider__Evt::union_selection_type union_selection;
union {
NS__Provider__LinkStatus_template *field_link__status;
};
} single_value;
struct {
unsigned int n_values;
NS__Provider__Evt_template *list_value;
} value_list;
struct {
NS__Provider__Evt_template* precondition;
NS__Provider__Evt_template* implied_template;
} implication_;
dynmatch_struct<NS__Provider__Evt>* dyn_match;
};
void copy_value(const NS__Provider__Evt& other_value);

void copy_template(const NS__Provider__Evt_template& other_value);

public:
NS__Provider__Evt_template();
NS__Provider__Evt_template(template_sel other_value);
NS__Provider__Evt_template(const NS__Provider__Evt& other_value);
NS__Provider__Evt_template(const OPTIONAL<NS__Provider__Evt>& other_value);
NS__Provider__Evt_template(NS__Provider__Evt_template* p_precondition, NS__Provider__Evt_template* p_implied_template);
NS__Provider__Evt_template(Dynamic_Match_Interface<NS__Provider__Evt>* p_dyn_match);
NS__Provider__Evt_template(const NS__Provider__Evt_template& other_value);
~NS__Provider__Evt_template();
void clean_up();
NS__Provider__Evt_template& operator=(template_sel other_value);
NS__Provider__Evt_template& operator=(const NS__Provider__Evt& other_value);
NS__Provider__Evt_template& operator=(const OPTIONAL<NS__Provider__Evt>& other_value);
NS__Provider__Evt_template& operator=(const NS__Provider__Evt_template& other_value);
boolean match(const NS__Provider__Evt& other_value, boolean legacy = FALSE) const;
boolean is_value() const;NS__Provider__Evt valueof() const;
NS__Provider__Evt_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
NS__Provider__LinkStatus_template& link__status();
const NS__Provider__LinkStatus_template& link__status() const;
boolean ischosen(NS__Provider__Evt::union_selection_type checked_selection) const;
void log() const;
void log_match(const NS__Provider__Evt& 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 NS__PROVIDER__PT : public PORT {
enum msg_selection { MESSAGE_0, MESSAGE_1 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
NS__Types::PDU__NS *message_0;
NS__Provider__Evt *message_1;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
NS__PROVIDER__PT(const char *par_port_name = NULL);
~NS__PROVIDER__PT();
void send(const NS__Types::PDU__NS& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NS__Types::PDU__NS& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NS__Types::PDU__NS_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NS__Types::PDU__NS_template& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NS__Provider__Evt& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NS__Provider__Evt& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NS__Provider__Evt_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NS__Provider__Evt_template& send_par, 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 NS__Types::PDU__NS_template& value_template, NS__Types::PDU__NS *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NS__Types::PDU__NS_template& value_template, NS__Types::PDU__NS *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NS__Types::PDU__NS_template& value_template, NS__Types::PDU__NS *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const NS__Provider__Evt_template& value_template, NS__Provider__Evt *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NS__Provider__Evt_template& value_template, NS__Provider__Evt *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NS__Provider__Evt_template& value_template, NS__Provider__Evt *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const NS__Types::PDU__NS& incoming_par, component sender_component);
void incoming_message(const NS__Provider__Evt& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class NSVCConfigurationIP {
  Osmocom__Types::AddressFamily field_address__family;
  INTEGER field_local__udp__port;
  CHARSTRING field_local__ip;
  INTEGER field_remote__udp__port;
  CHARSTRING field_remote__ip;
  INTEGER field_data__weight;
  INTEGER field_signalling__weight;
public:
  NSVCConfigurationIP();
  NSVCConfigurationIP(const Osmocom__Types::AddressFamily& par_address__family,
    const INTEGER& par_local__udp__port,
    const CHARSTRING& par_local__ip,
    const INTEGER& par_remote__udp__port,
    const CHARSTRING& par_remote__ip,
    const INTEGER& par_data__weight,
    const INTEGER& par_signalling__weight);
  NSVCConfigurationIP(const NSVCConfigurationIP& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  NSVCConfigurationIP& operator=(const NSVCConfigurationIP& other_value);
  boolean operator==(const NSVCConfigurationIP& other_value) const;
  inline boolean operator!=(const NSVCConfigurationIP& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline Osmocom__Types::AddressFamily& address__family()
    {return field_address__family;}
  inline const Osmocom__Types::AddressFamily& address__family() const
    {return field_address__family;}
  inline INTEGER& local__udp__port()
    {return field_local__udp__port;}
  inline const INTEGER& local__udp__port() const
    {return field_local__udp__port;}
  inline CHARSTRING& local__ip()
    {return field_local__ip;}
  inline const CHARSTRING& local__ip() const
    {return field_local__ip;}
  inline INTEGER& remote__udp__port()
    {return field_remote__udp__port;}
  inline const INTEGER& remote__udp__port() const
    {return field_remote__udp__port;}
  inline CHARSTRING& remote__ip()
    {return field_remote__ip;}
  inline const CHARSTRING& remote__ip() const
    {return field_remote__ip;}
  inline INTEGER& data__weight()
    {return field_data__weight;}
  inline const INTEGER& data__weight() const
    {return field_data__weight;}
  inline INTEGER& signalling__weight()
    {return field_signalling__weight;}
  inline const INTEGER& signalling__weight() const
    {return field_signalling__weight;}
  inline int size_of() const
    {return 7;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
};

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

void set_specific();
void copy_value(const NSVCConfigurationIP& other_value);
void copy_template(const NSVCConfigurationIP_template& other_value);

public:
NSVCConfigurationIP_template();
NSVCConfigurationIP_template(template_sel other_value);
NSVCConfigurationIP_template(const NSVCConfigurationIP& other_value);
NSVCConfigurationIP_template(const OPTIONAL<NSVCConfigurationIP>& other_value);
NSVCConfigurationIP_template(NSVCConfigurationIP_template* p_precondition, NSVCConfigurationIP_template* p_implied_template);
NSVCConfigurationIP_template(Dynamic_Match_Interface<NSVCConfigurationIP>* p_dyn_match);
NSVCConfigurationIP_template(const NSVCConfigurationIP_template& other_value);
~NSVCConfigurationIP_template();
NSVCConfigurationIP_template& operator=(template_sel other_value);
NSVCConfigurationIP_template& operator=(const NSVCConfigurationIP& other_value);
NSVCConfigurationIP_template& operator=(const OPTIONAL<NSVCConfigurationIP>& other_value);
NSVCConfigurationIP_template& operator=(const NSVCConfigurationIP_template& other_value);
boolean match(const NSVCConfigurationIP& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
NSVCConfigurationIP valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NSVCConfigurationIP_template& list_item(unsigned int list_index) const;
Osmocom__Types::AddressFamily_template& address__family();
const Osmocom__Types::AddressFamily_template& address__family() const;
INTEGER_template& local__udp__port();
const INTEGER_template& local__udp__port() const;
CHARSTRING_template& local__ip();
const CHARSTRING_template& local__ip() const;
INTEGER_template& remote__udp__port();
const INTEGER_template& remote__udp__port() const;
CHARSTRING_template& remote__ip();
const CHARSTRING_template& remote__ip() const;
INTEGER_template& data__weight();
const INTEGER_template& data__weight() const;
INTEGER_template& signalling__weight();
const INTEGER_template& signalling__weight() const;
int size_of() const;
void log() const;
void log_match(const NSVCConfigurationIP& match_value, boolean legacy = FALSE) const;
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 NSVCConfigurationFR {
  CHARSTRING field_netdev;
  INTEGER field_dlci;
public:
  NSVCConfigurationFR();
  NSVCConfigurationFR(const CHARSTRING& par_netdev,
    const INTEGER& par_dlci);
  NSVCConfigurationFR(const NSVCConfigurationFR& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  NSVCConfigurationFR& operator=(const NSVCConfigurationFR& other_value);
  boolean operator==(const NSVCConfigurationFR& other_value) const;
  inline boolean operator!=(const NSVCConfigurationFR& 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& netdev()
    {return field_netdev;}
  inline const CHARSTRING& netdev() const
    {return field_netdev;}
  inline INTEGER& dlci()
    {return field_dlci;}
  inline const INTEGER& dlci() const
    {return field_dlci;}
  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 NSVCConfigurationFR_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
NSVCConfigurationFR_template *list_value;
} value_list;
struct {
NSVCConfigurationFR_template* precondition;
NSVCConfigurationFR_template* implied_template;
} implication_;
dynmatch_struct<NSVCConfigurationFR>* dyn_match;
};

void set_specific();
void copy_value(const NSVCConfigurationFR& other_value);
void copy_template(const NSVCConfigurationFR_template& other_value);

public:
NSVCConfigurationFR_template();
NSVCConfigurationFR_template(template_sel other_value);
NSVCConfigurationFR_template(const NSVCConfigurationFR& other_value);
NSVCConfigurationFR_template(const OPTIONAL<NSVCConfigurationFR>& other_value);
NSVCConfigurationFR_template(NSVCConfigurationFR_template* p_precondition, NSVCConfigurationFR_template* p_implied_template);
NSVCConfigurationFR_template(Dynamic_Match_Interface<NSVCConfigurationFR>* p_dyn_match);
NSVCConfigurationFR_template(const NSVCConfigurationFR_template& other_value);
~NSVCConfigurationFR_template();
NSVCConfigurationFR_template& operator=(template_sel other_value);
NSVCConfigurationFR_template& operator=(const NSVCConfigurationFR& other_value);
NSVCConfigurationFR_template& operator=(const OPTIONAL<NSVCConfigurationFR>& other_value);
NSVCConfigurationFR_template& operator=(const NSVCConfigurationFR_template& other_value);
boolean match(const NSVCConfigurationFR& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
NSVCConfigurationFR valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NSVCConfigurationFR_template& list_item(unsigned int list_index) const;
CHARSTRING_template& netdev();
const CHARSTRING_template& netdev() const;
INTEGER_template& dlci();
const INTEGER_template& dlci() const;
int size_of() const;
void log() const;
void log_match(const NSVCConfigurationFR& match_value, boolean legacy = FALSE) const;
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 NSVCConfigurationP : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_ip = 1, ALT_fr = 2 };
private:
union_selection_type union_selection;
union {
NSVCConfigurationIP *field_ip;
NSVCConfigurationFR *field_fr;
};
void copy_value(const NSVCConfigurationP& other_value);

public:
NSVCConfigurationP();
NSVCConfigurationP(const NSVCConfigurationP& other_value);
~NSVCConfigurationP();
NSVCConfigurationP& operator=(const NSVCConfigurationP& other_value);
boolean operator==(const NSVCConfigurationP& other_value) const;
inline boolean operator!=(const NSVCConfigurationP& other_value) const { return !(*this == other_value); }
NSVCConfigurationIP& ip();
const NSVCConfigurationIP& ip() const;
NSVCConfigurationFR& fr();
const NSVCConfigurationFR& fr() const;
inline union_selection_type get_selection() const { return union_selection; }
boolean ischosen(union_selection_type checked_selection) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class NSVCConfigurationP_template : public Base_Template {
union {
struct {
NSVCConfigurationP::union_selection_type union_selection;
union {
NSVCConfigurationIP_template *field_ip;
NSVCConfigurationFR_template *field_fr;
};
} single_value;
struct {
unsigned int n_values;
NSVCConfigurationP_template *list_value;
} value_list;
struct {
NSVCConfigurationP_template* precondition;
NSVCConfigurationP_template* implied_template;
} implication_;
dynmatch_struct<NSVCConfigurationP>* dyn_match;
};
void copy_value(const NSVCConfigurationP& other_value);

void copy_template(const NSVCConfigurationP_template& other_value);

public:
NSVCConfigurationP_template();
NSVCConfigurationP_template(template_sel other_value);
NSVCConfigurationP_template(const NSVCConfigurationP& other_value);
NSVCConfigurationP_template(const OPTIONAL<NSVCConfigurationP>& other_value);
NSVCConfigurationP_template(NSVCConfigurationP_template* p_precondition, NSVCConfigurationP_template* p_implied_template);
NSVCConfigurationP_template(Dynamic_Match_Interface<NSVCConfigurationP>* p_dyn_match);
NSVCConfigurationP_template(const NSVCConfigurationP_template& other_value);
~NSVCConfigurationP_template();
void clean_up();
NSVCConfigurationP_template& operator=(template_sel other_value);
NSVCConfigurationP_template& operator=(const NSVCConfigurationP& other_value);
NSVCConfigurationP_template& operator=(const OPTIONAL<NSVCConfigurationP>& other_value);
NSVCConfigurationP_template& operator=(const NSVCConfigurationP_template& other_value);
boolean match(const NSVCConfigurationP& other_value, boolean legacy = FALSE) const;
boolean is_value() const;NSVCConfigurationP valueof() const;
NSVCConfigurationP_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
NSVCConfigurationIP_template& ip();
const NSVCConfigurationIP_template& ip() const;
NSVCConfigurationFR_template& fr();
const NSVCConfigurationFR_template& fr() const;
boolean ischosen(NSVCConfigurationP::union_selection_type checked_selection) const;
void log() const;
void log_match(const NSVCConfigurationP& 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 NSVCConfiguration {
  NSVCConfigurationP field_provider;
  INTEGER field_nsvci;
public:
  NSVCConfiguration();
  NSVCConfiguration(const NSVCConfigurationP& par_provider,
    const INTEGER& par_nsvci);
  NSVCConfiguration(const NSVCConfiguration& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  NSVCConfiguration& operator=(const NSVCConfiguration& other_value);
  boolean operator==(const NSVCConfiguration& other_value) const;
  inline boolean operator!=(const NSVCConfiguration& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline NSVCConfigurationP& provider()
    {return field_provider;}
  inline const NSVCConfigurationP& provider() const
    {return field_provider;}
  inline INTEGER& nsvci()
    {return field_nsvci;}
  inline const INTEGER& nsvci() const
    {return field_nsvci;}
  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 NSVCConfiguration_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
NSVCConfiguration_template *list_value;
} value_list;
struct {
NSVCConfiguration_template* precondition;
NSVCConfiguration_template* implied_template;
} implication_;
dynmatch_struct<NSVCConfiguration>* dyn_match;
};

void set_specific();
void copy_value(const NSVCConfiguration& other_value);
void copy_template(const NSVCConfiguration_template& other_value);

public:
NSVCConfiguration_template();
NSVCConfiguration_template(template_sel other_value);
NSVCConfiguration_template(const NSVCConfiguration& other_value);
NSVCConfiguration_template(const OPTIONAL<NSVCConfiguration>& other_value);
NSVCConfiguration_template(NSVCConfiguration_template* p_precondition, NSVCConfiguration_template* p_implied_template);
NSVCConfiguration_template(Dynamic_Match_Interface<NSVCConfiguration>* p_dyn_match);
NSVCConfiguration_template(const NSVCConfiguration_template& other_value);
~NSVCConfiguration_template();
NSVCConfiguration_template& operator=(template_sel other_value);
NSVCConfiguration_template& operator=(const NSVCConfiguration& other_value);
NSVCConfiguration_template& operator=(const OPTIONAL<NSVCConfiguration>& other_value);
NSVCConfiguration_template& operator=(const NSVCConfiguration_template& other_value);
boolean match(const NSVCConfiguration& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
NSVCConfiguration valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NSVCConfiguration_template& list_item(unsigned int list_index) const;
NSVCConfigurationP_template& provider();
const NSVCConfigurationP_template& provider() const;
INTEGER_template& nsvci();
const INTEGER_template& nsvci() const;
int size_of() const;
void log() const;
void log_match(const NSVCConfiguration& match_value, boolean legacy = FALSE) const;
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 NSVCConfigurations : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
NSVCConfiguration **value_elements;
} *val_ptr;

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

public:
  typedef NSVCConfiguration of_type;
NSVCConfigurations();
NSVCConfigurations(null_type other_value);
NSVCConfigurations(const NSVCConfigurations& other_value);
~NSVCConfigurations();

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

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

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

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

NSVCConfigurations operator+(const NSVCConfigurations& other_value) const;

NSVCConfigurations substr(int index, int returncount) const;

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

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

void clean_up();
NSVCConfigurations_template& operator=(template_sel other_value);
NSVCConfigurations_template& operator=(null_type other_value);
NSVCConfigurations_template& operator=(const NSVCConfigurations& other_value);
NSVCConfigurations_template& operator=(const OPTIONAL<NSVCConfigurations>& other_value);
NSVCConfigurations_template& operator=(const NSVCConfigurations_template& other_value);

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

NSVCConfigurations replace(int index, int len, const NSVCConfigurations_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
NSVCConfigurations_template& list_item(unsigned int list_index);
void log() const;
void log_match(const NSVCConfigurations& 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;
boolean get_istemplate_kind(const char* type) const;
};

class NSConfiguration {
  INTEGER field_nsei;
  BOOLEAN field_role__sgsn;
  BOOLEAN field_handle__sns;
  NSVCConfigurations field_nsvc;
public:
  NSConfiguration();
  NSConfiguration(const INTEGER& par_nsei,
    const BOOLEAN& par_role__sgsn,
    const BOOLEAN& par_handle__sns,
    const NSVCConfigurations& par_nsvc);
  NSConfiguration(const NSConfiguration& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  NSConfiguration& operator=(const NSConfiguration& other_value);
  boolean operator==(const NSConfiguration& other_value) const;
  inline boolean operator!=(const NSConfiguration& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& nsei()
    {return field_nsei;}
  inline const INTEGER& nsei() const
    {return field_nsei;}
  inline BOOLEAN& role__sgsn()
    {return field_role__sgsn;}
  inline const BOOLEAN& role__sgsn() const
    {return field_role__sgsn;}
  inline BOOLEAN& handle__sns()
    {return field_handle__sns;}
  inline const BOOLEAN& handle__sns() const
    {return field_handle__sns;}
  inline NSVCConfigurations& nsvc()
    {return field_nsvc;}
  inline const NSVCConfigurations& nsvc() const
    {return field_nsvc;}
  inline int size_of() const
    {return 4;}
  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 NSConfiguration_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
NSConfiguration_template *list_value;
} value_list;
struct {
NSConfiguration_template* precondition;
NSConfiguration_template* implied_template;
} implication_;
dynmatch_struct<NSConfiguration>* dyn_match;
};

void set_specific();
void copy_value(const NSConfiguration& other_value);
void copy_template(const NSConfiguration_template& other_value);

public:
NSConfiguration_template();
NSConfiguration_template(template_sel other_value);
NSConfiguration_template(const NSConfiguration& other_value);
NSConfiguration_template(const OPTIONAL<NSConfiguration>& other_value);
NSConfiguration_template(NSConfiguration_template* p_precondition, NSConfiguration_template* p_implied_template);
NSConfiguration_template(Dynamic_Match_Interface<NSConfiguration>* p_dyn_match);
NSConfiguration_template(const NSConfiguration_template& other_value);
~NSConfiguration_template();
NSConfiguration_template& operator=(template_sel other_value);
NSConfiguration_template& operator=(const NSConfiguration& other_value);
NSConfiguration_template& operator=(const OPTIONAL<NSConfiguration>& other_value);
NSConfiguration_template& operator=(const NSConfiguration_template& other_value);
boolean match(const NSConfiguration& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
NSConfiguration valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NSConfiguration_template& list_item(unsigned int list_index) const;
INTEGER_template& nsei();
const INTEGER_template& nsei() const;
BOOLEAN_template& role__sgsn();
const BOOLEAN_template& role__sgsn() const;
BOOLEAN_template& handle__sns();
const BOOLEAN_template& handle__sns() const;
NSVCConfigurations_template& nsvc();
const NSVCConfigurations_template& nsvc() const;
int size_of() const;
void log() const;
void log_match(const NSConfiguration& match_value, boolean legacy = FALSE) const;
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 IpEndpointTable : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
IpEndpointTableEntry **value_elements;
} *val_ptr;

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

public:
  typedef IpEndpointTableEntry of_type;
IpEndpointTable();
IpEndpointTable(null_type other_value);
IpEndpointTable(const IpEndpointTable& other_value);
~IpEndpointTable();

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

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

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

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

IpEndpointTable operator+(const IpEndpointTable& other_value) const;

IpEndpointTable substr(int index, int returncount) const;

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

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

void clean_up();
IpEndpointTable_template& operator=(template_sel other_value);
IpEndpointTable_template& operator=(null_type other_value);
IpEndpointTable_template& operator=(const IpEndpointTable& other_value);
IpEndpointTable_template& operator=(const OPTIONAL<IpEndpointTable>& other_value);
IpEndpointTable_template& operator=(const IpEndpointTable_template& other_value);

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

IpEndpointTable replace(int index, int len, const IpEndpointTable_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
IpEndpointTable_template& list_item(unsigned int list_index);
void log() const;
void log_match(const IpEndpointTable& 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;
boolean get_istemplate_kind(const char* type) const;
};

class IpEndpointTableEntry {
  Osmocom__Types::AddressFamily field_address__family;
  INTEGER field_local__udp__port;
  CHARSTRING field_local__ip;
  INTEGER field_data__weight;
  INTEGER field_signalling__weight;
  COMPONENT field_provider__ct;
public:
  IpEndpointTableEntry();
  IpEndpointTableEntry(const Osmocom__Types::AddressFamily& par_address__family,
    const INTEGER& par_local__udp__port,
    const CHARSTRING& par_local__ip,
    const INTEGER& par_data__weight,
    const INTEGER& par_signalling__weight,
    const COMPONENT& par_provider__ct);
  IpEndpointTableEntry(const IpEndpointTableEntry& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  IpEndpointTableEntry& operator=(const IpEndpointTableEntry& other_value);
  boolean operator==(const IpEndpointTableEntry& other_value) const;
  inline boolean operator!=(const IpEndpointTableEntry& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline Osmocom__Types::AddressFamily& address__family()
    {return field_address__family;}
  inline const Osmocom__Types::AddressFamily& address__family() const
    {return field_address__family;}
  inline INTEGER& local__udp__port()
    {return field_local__udp__port;}
  inline const INTEGER& local__udp__port() const
    {return field_local__udp__port;}
  inline CHARSTRING& local__ip()
    {return field_local__ip;}
  inline const CHARSTRING& local__ip() const
    {return field_local__ip;}
  inline INTEGER& data__weight()
    {return field_data__weight;}
  inline const INTEGER& data__weight() const
    {return field_data__weight;}
  inline INTEGER& signalling__weight()
    {return field_signalling__weight;}
  inline const INTEGER& signalling__weight() const
    {return field_signalling__weight;}
  inline COMPONENT& provider__ct()
    {return field_provider__ct;}
  inline const COMPONENT& provider__ct() const
    {return field_provider__ct;}
  inline int size_of() const
    {return 6;}
  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 IpEndpointTableEntry_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
IpEndpointTableEntry_template *list_value;
} value_list;
struct {
IpEndpointTableEntry_template* precondition;
IpEndpointTableEntry_template* implied_template;
} implication_;
dynmatch_struct<IpEndpointTableEntry>* dyn_match;
};

void set_specific();
void copy_value(const IpEndpointTableEntry& other_value);
void copy_template(const IpEndpointTableEntry_template& other_value);

public:
IpEndpointTableEntry_template();
IpEndpointTableEntry_template(template_sel other_value);
IpEndpointTableEntry_template(const IpEndpointTableEntry& other_value);
IpEndpointTableEntry_template(const OPTIONAL<IpEndpointTableEntry>& other_value);
IpEndpointTableEntry_template(IpEndpointTableEntry_template* p_precondition, IpEndpointTableEntry_template* p_implied_template);
IpEndpointTableEntry_template(Dynamic_Match_Interface<IpEndpointTableEntry>* p_dyn_match);
IpEndpointTableEntry_template(const IpEndpointTableEntry_template& other_value);
~IpEndpointTableEntry_template();
IpEndpointTableEntry_template& operator=(template_sel other_value);
IpEndpointTableEntry_template& operator=(const IpEndpointTableEntry& other_value);
IpEndpointTableEntry_template& operator=(const OPTIONAL<IpEndpointTableEntry>& other_value);
IpEndpointTableEntry_template& operator=(const IpEndpointTableEntry_template& other_value);
boolean match(const IpEndpointTableEntry& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
IpEndpointTableEntry valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
IpEndpointTableEntry_template& list_item(unsigned int list_index) const;
Osmocom__Types::AddressFamily_template& address__family();
const Osmocom__Types::AddressFamily_template& address__family() const;
INTEGER_template& local__udp__port();
const INTEGER_template& local__udp__port() const;
CHARSTRING_template& local__ip();
const CHARSTRING_template& local__ip() const;
INTEGER_template& data__weight();
const INTEGER_template& data__weight() const;
INTEGER_template& signalling__weight();
const INTEGER_template& signalling__weight() const;
COMPONENT_template& provider__ct();
const COMPONENT_template& provider__ct() const;
int size_of() const;
void log() const;
void log_match(const IpEndpointTableEntry& match_value, boolean legacy = FALSE) const;
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 NsvcTable : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
NsvcTableEntry **value_elements;
} *val_ptr;

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

public:
  typedef NsvcTableEntry of_type;
NsvcTable();
NsvcTable(null_type other_value);
NsvcTable(const NsvcTable& other_value);
~NsvcTable();

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

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

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

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

NsvcTable operator+(const NsvcTable& other_value) const;

NsvcTable substr(int index, int returncount) const;

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

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

void clean_up();
NsvcTable_template& operator=(template_sel other_value);
NsvcTable_template& operator=(null_type other_value);
NsvcTable_template& operator=(const NsvcTable& other_value);
NsvcTable_template& operator=(const OPTIONAL<NsvcTable>& other_value);
NsvcTable_template& operator=(const NsvcTable_template& other_value);

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

NsvcTable replace(int index, int len, const NsvcTable_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
NsvcTable_template& list_item(unsigned int list_index);
void log() const;
void log_match(const NsvcTable& 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;
boolean get_istemplate_kind(const char* type) const;
};

class NsvcTableEntry {
  NSVCConfiguration field_cfg;
  COMPONENT field_vc__conn;
  NsvcState field_state;
public:
  NsvcTableEntry();
  NsvcTableEntry(const NSVCConfiguration& par_cfg,
    const COMPONENT& par_vc__conn,
    const NsvcState& par_state);
  NsvcTableEntry(const NsvcTableEntry& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  NsvcTableEntry& operator=(const NsvcTableEntry& other_value);
  boolean operator==(const NsvcTableEntry& other_value) const;
  inline boolean operator!=(const NsvcTableEntry& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline NSVCConfiguration& cfg()
    {return field_cfg;}
  inline const NSVCConfiguration& cfg() const
    {return field_cfg;}
  inline COMPONENT& vc__conn()
    {return field_vc__conn;}
  inline const COMPONENT& vc__conn() const
    {return field_vc__conn;}
  inline NsvcState& state()
    {return field_state;}
  inline const NsvcState& state() const
    {return field_state;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
};

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

void set_specific();
void copy_value(const NsvcTableEntry& other_value);
void copy_template(const NsvcTableEntry_template& other_value);

public:
NsvcTableEntry_template();
NsvcTableEntry_template(template_sel other_value);
NsvcTableEntry_template(const NsvcTableEntry& other_value);
NsvcTableEntry_template(const OPTIONAL<NsvcTableEntry>& other_value);
NsvcTableEntry_template(NsvcTableEntry_template* p_precondition, NsvcTableEntry_template* p_implied_template);
NsvcTableEntry_template(Dynamic_Match_Interface<NsvcTableEntry>* p_dyn_match);
NsvcTableEntry_template(const NsvcTableEntry_template& other_value);
~NsvcTableEntry_template();
NsvcTableEntry_template& operator=(template_sel other_value);
NsvcTableEntry_template& operator=(const NsvcTableEntry& other_value);
NsvcTableEntry_template& operator=(const OPTIONAL<NsvcTableEntry>& other_value);
NsvcTableEntry_template& operator=(const NsvcTableEntry_template& other_value);
boolean match(const NsvcTableEntry& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
NsvcTableEntry valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NsvcTableEntry_template& list_item(unsigned int list_index) const;
NSVCConfiguration_template& cfg();
const NSVCConfiguration_template& cfg() const;
COMPONENT_template& vc__conn();
const COMPONENT_template& vc__conn() const;
NsvcState_template& state();
const NsvcState_template& state() const;
int size_of() const;
void log() const;
void log_match(const NsvcTableEntry& match_value, boolean legacy = FALSE) const;
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 NSint__SP__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 {
NsUnitdataRequest *message_0;
SnsRequest *message_1;
NsCtrlRequest *message_2;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
NSint__SP__PT(const char *par_port_name = NULL);
~NSint__SP__PT();
void send(const NsUnitdataIndication& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataIndication& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataIndication_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataIndication_template& send_par, FLOAT* timestamp_redirect = NULL);
void send(const SnsIndication& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const SnsIndication& send_par, FLOAT* timestamp_redirect = NULL);
void send(const SnsIndication_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const SnsIndication_template& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsStatusIndication& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsStatusIndication& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsStatusIndication_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsStatusIndication_template& send_par, 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 NsUnitdataRequest_template& value_template, NsUnitdataRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NsUnitdataRequest_template& value_template, NsUnitdataRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NsUnitdataRequest_template& value_template, NsUnitdataRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const SnsRequest_template& value_template, SnsRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const SnsRequest_template& value_template, SnsRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const SnsRequest_template& value_template, SnsRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const NsCtrlRequest_template& value_template, NsCtrlRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NsCtrlRequest_template& value_template, NsCtrlRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NsCtrlRequest_template& value_template, NsCtrlRequest *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const NsUnitdataRequest& incoming_par, component sender_component);
void incoming_message(const SnsRequest& incoming_par, component sender_component);
void incoming_message(const NsCtrlRequest& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class NSint__PT : public PORT {
enum msg_selection { MESSAGE_0, MESSAGE_1, MESSAGE_2, MESSAGE_3 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
Socket__API__Definitions::PortEvent *message_0;
NsStatusIndication *message_1;
SnsIndication *message_2;
NsUnitdataIndication *message_3;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
NSint__PT(const char *par_port_name = NULL);
~NSint__PT();
void send(const NsUnitdataRequest& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataRequest& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataRequest_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsUnitdataRequest_template& send_par, FLOAT* timestamp_redirect = NULL);
void send(const SnsRequest& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const SnsRequest& send_par, FLOAT* timestamp_redirect = NULL);
void send(const SnsRequest_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const SnsRequest_template& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsCtrlRequest& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsCtrlRequest& send_par, FLOAT* timestamp_redirect = NULL);
void send(const NsCtrlRequest_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const NsCtrlRequest_template& send_par, 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 Socket__API__Definitions::PortEvent_template& value_template, Socket__API__Definitions::PortEvent *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const Socket__API__Definitions::PortEvent_template& value_template, Socket__API__Definitions::PortEvent *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const Socket__API__Definitions::PortEvent_template& value_template, Socket__API__Definitions::PortEvent *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const NsStatusIndication_template& value_template, NsStatusIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NsStatusIndication_template& value_template, NsStatusIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NsStatusIndication_template& value_template, NsStatusIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const SnsIndication_template& value_template, SnsIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const SnsIndication_template& value_template, SnsIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const SnsIndication_template& value_template, SnsIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const NsUnitdataIndication_template& value_template, NsUnitdataIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const NsUnitdataIndication_template& value_template, NsUnitdataIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const NsUnitdataIndication_template& value_template, NsUnitdataIndication *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const Socket__API__Definitions::PortEvent& incoming_par, component sender_component);
void incoming_message(const NsStatusIndication& incoming_par, component sender_component);
void incoming_message(const SnsIndication& incoming_par, component sender_component);
void incoming_message(const NsUnitdataIndication& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class SnsIndication {
  INTEGER field_nsvci;
  NS__Types::PDU__NS field_ns;
public:
  SnsIndication();
  SnsIndication(const INTEGER& par_nsvci,
    const NS__Types::PDU__NS& par_ns);
  SnsIndication(const SnsIndication& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SnsIndication& operator=(const SnsIndication& other_value);
  boolean operator==(const SnsIndication& other_value) const;
  inline boolean operator!=(const SnsIndication& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& nsvci()
    {return field_nsvci;}
  inline const INTEGER& nsvci() const
    {return field_nsvci;}
  inline NS__Types::PDU__NS& ns()
    {return field_ns;}
  inline const NS__Types::PDU__NS& ns() const
    {return field_ns;}
  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 SnsIndication_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SnsIndication_template *list_value;
} value_list;
struct {
SnsIndication_template* precondition;
SnsIndication_template* implied_template;
} implication_;
dynmatch_struct<SnsIndication>* dyn_match;
};

void set_specific();
void copy_value(const SnsIndication& other_value);
void copy_template(const SnsIndication_template& other_value);

public:
SnsIndication_template();
SnsIndication_template(template_sel other_value);
SnsIndication_template(const SnsIndication& other_value);
SnsIndication_template(const OPTIONAL<SnsIndication>& other_value);
SnsIndication_template(SnsIndication_template* p_precondition, SnsIndication_template* p_implied_template);
SnsIndication_template(Dynamic_Match_Interface<SnsIndication>* p_dyn_match);
SnsIndication_template(const SnsIndication_template& other_value);
~SnsIndication_template();
SnsIndication_template& operator=(template_sel other_value);
SnsIndication_template& operator=(const SnsIndication& other_value);
SnsIndication_template& operator=(const OPTIONAL<SnsIndication>& other_value);
SnsIndication_template& operator=(const SnsIndication_template& other_value);
boolean match(const SnsIndication& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SnsIndication valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SnsIndication_template& list_item(unsigned int list_index) const;
INTEGER_template& nsvci();
const INTEGER_template& nsvci() const;
NS__Types::PDU__NS_template& ns();
const NS__Types::PDU__NS_template& ns() const;
int size_of() const;
void log() const;
void log_match(const SnsIndication& match_value, boolean legacy = FALSE) const;
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 SnsRequest {
  INTEGER field_nsvci;
  NS__Types::PDU__NS field_ns;
public:
  SnsRequest();
  SnsRequest(const INTEGER& par_nsvci,
    const NS__Types::PDU__NS& par_ns);
  SnsRequest(const SnsRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SnsRequest& operator=(const SnsRequest& other_value);
  boolean operator==(const SnsRequest& other_value) const;
  inline boolean operator!=(const SnsRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& nsvci()
    {return field_nsvci;}
  inline const INTEGER& nsvci() const
    {return field_nsvci;}
  inline NS__Types::PDU__NS& ns()
    {return field_ns;}
  inline const NS__Types::PDU__NS& ns() const
    {return field_ns;}
  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 SnsRequest_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SnsRequest_template *list_value;
} value_list;
struct {
SnsRequest_template* precondition;
SnsRequest_template* implied_template;
} implication_;
dynmatch_struct<SnsRequest>* dyn_match;
};

void set_specific();
void copy_value(const SnsRequest& other_value);
void copy_template(const SnsRequest_template& other_value);

public:
SnsRequest_template();
SnsRequest_template(template_sel other_value);
SnsRequest_template(const SnsRequest& other_value);
SnsRequest_template(const OPTIONAL<SnsRequest>& other_value);
SnsRequest_template(SnsRequest_template* p_precondition, SnsRequest_template* p_implied_template);
SnsRequest_template(Dynamic_Match_Interface<SnsRequest>* p_dyn_match);
SnsRequest_template(const SnsRequest_template& other_value);
~SnsRequest_template();
SnsRequest_template& operator=(template_sel other_value);
SnsRequest_template& operator=(const SnsRequest& other_value);
SnsRequest_template& operator=(const OPTIONAL<SnsRequest>& other_value);
SnsRequest_template& operator=(const SnsRequest_template& other_value);
boolean match(const SnsRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SnsRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SnsRequest_template& list_item(unsigned int list_index) const;
INTEGER_template& nsvci();
const INTEGER_template& nsvci() const;
NS__Types::PDU__NS_template& ns();
const NS__Types::PDU__NS_template& ns() const;
int size_of() const;
void log() const;
void log_match(const SnsRequest& match_value, boolean legacy = FALSE) const;
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 NsCtrlRequest : public Base_Type { // enum
friend class NsCtrlRequest_template;
public:
enum enum_type { StartAliveProcedure = 0, DisableReq = 1, EnableReq = 2, ForceAliveState = 3, UNKNOWN_VALUE = 4, UNBOUND_VALUE = 5 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const NsCtrlRequest& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const NsCtrlRequest& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const NsCtrlRequest& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const NsCtrlRequest& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const NsCtrlRequest& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const NsCtrlRequest& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const NsCtrlRequest& 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 NsCtrlRequest_template : public Base_Template {
union {
NsCtrlRequest::enum_type single_value;
struct {
unsigned int n_values;
NsCtrlRequest_template *list_value;
} value_list;
struct {
NsCtrlRequest_template* precondition;
NsCtrlRequest_template* implied_template;
} implication_;
dynmatch_struct<NsCtrlRequest>* dyn_match;
};

void copy_template(const NsCtrlRequest_template& other_value);

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

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

boolean match(NsCtrlRequest::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const NsCtrlRequest& other_value, boolean legacy = FALSE) const;
NsCtrlRequest::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
NsCtrlRequest_template& list_item(unsigned int list_index);
void log() const;
void log_match(const NsCtrlRequest& 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 as__ns__common__status_Default : public Default_Base {
public:
as__ns__common__status_Default();
alt_status call_altstep();
};

class as__ns__common_Default : public Default_Base {
public:
as__ns__common_Default();
alt_status call_altstep();
};

class as__vcg__sns__pcu_Default : public Default_Base {
public:
as__vcg__sns__pcu_Default();
alt_status call_altstep();
};

class as__vcg__sns__sgsn_Default : public Default_Base {
public:
as__vcg__sns__sgsn_Default();
alt_status call_altstep();
};

class as__allstate_Default : public Default_Base {
public:
as__allstate_Default();
alt_status call_altstep();
};

class as__disabled_Default : public Default_Base {
public:
as__disabled_Default();
alt_status call_altstep();
};

class as__handle__reset_Default : public Default_Base {
public:
as__handle__reset_Default();
alt_status call_altstep();
};

class as__nsvc__sns_Default : public Default_Base {
public:
as__nsvc__sns_Default();
alt_status call_altstep();
};

class as__alive__blocked_Default : public Default_Base {
public:
as__alive__blocked_Default();
alt_status call_altstep();
};

class as__alive__unblocked_Default : public Default_Base {
public:
as__alive__unblocked_Default();
alt_status call_altstep();
};

class as__alive__unblocked__data_Default : public Default_Base {
public:
as__alive__unblocked__data_Default();
alt_status call_altstep();
};

class as__alive__unblocked__sig_Default : public Default_Base {
public:
as__alive__unblocked__sig_Default();
alt_status call_altstep();
};

class as__wait__reset_Default : public Default_Base {
public:
as__wait__reset_Default();
alt_status call_altstep();
};


/* Function prototypes */

extern NsUnitdataRequest_template tr__NsUdReq(const INTEGER_template& nsei, const INTEGER_template& bvci, const INTEGER_template& lsp, const OCTETSTRING_template& sdu, const BSSGP__Types::PDU__BSSGP_template& bssgp);
extern NsUnitdataRequest_template ts__NsUdReq(const INTEGER_template& nsei, const INTEGER_template& bvci, const INTEGER_template& lsp, const OCTETSTRING_template& sdu, const BSSGP__Types::PDU__BSSGP_template& bssgp);
extern NsUnitdataIndication_template tr__NsUdInd(const INTEGER_template& nsei, const INTEGER_template& bvci, const OCTETSTRING_template& sdu);
extern NsUnitdataIndication_template ts__NsUdInd(const INTEGER& nsei, const INTEGER& nsvci, const INTEGER& bvci, const OCTETSTRING& sdu);
extern NsStatusIndication_template tr__NsStsInd(const INTEGER_template& nsei, const INTEGER_template& nsvci, const NsvcState_template& old__state, const NsvcState_template& state, const BOOLEAN_template& first__or__last);
extern NsStatusIndication_template ts__NsStsInd(const INTEGER& nsei, const INTEGER& nsvci, const NsvcState& old__state, const NsvcState& state, const BOOLEAN& first__or__last);
extern boolean operator==(null_type null_value, const NSVCConfigurations& other_value);
inline boolean operator!=(null_type null_value, const NSVCConfigurations& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const IpEndpointTable& other_value);
inline boolean operator!=(null_type null_value, const IpEndpointTable& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const NsvcTable& other_value);
inline boolean operator!=(null_type null_value, const NsvcTable& other_value) { return !(null_value == other_value); }
extern BOOLEAN f__ipep__find(const Osmocom__Types::AddressFamily& af, const INTEGER& local__udp__port, const CHARSTRING& local__ip, IpEndpointTableEntry& ret);
extern void start_f__ipep__find(const COMPONENT& component_reference, const Osmocom__Types::AddressFamily& af, const INTEGER& local__udp__port, const CHARSTRING& local__ip, IpEndpointTableEntry& ret);
extern COMPONENT f__ipep__find__or__create(const NSVCConfiguration& nsvc__cfg);
extern void start_f__ipep__find__or__create(const COMPONENT& component_reference, const NSVCConfiguration& nsvc__cfg);
extern void f__nsvc__add(const NSVCConfiguration& nsvc__cfg);
extern void start_f__nsvc__add(const COMPONENT& component_reference, const NSVCConfiguration& nsvc__cfg);
extern INTEGER f__nsvc__find__idx(const INTEGER& nsvci);
extern void start_f__nsvc__find__idx(const COMPONENT& component_reference, const INTEGER& nsvci);
extern COMPONENT f__nsvc__find(const INTEGER& nsvci);
extern void start_f__nsvc__find(const COMPONENT& component_reference, const INTEGER& nsvci);
extern void f__nsvc__update__state(const INTEGER& nsvci, const NsvcState& state);
extern void start_f__nsvc__update__state(const COMPONENT& component_reference, const INTEGER& nsvci, const NsvcState& state);
extern void NSStart(const NSConfiguration& init__config, const CHARSTRING& id);
extern void start_NSStart(const COMPONENT& component_reference, const NSConfiguration& init__config, const CHARSTRING& id);
extern INTEGER f__count__nsvcs__in__state(const NsvcState_template& state);
extern void start_f__count__nsvcs__in__state(const COMPONENT& component_reference, const NsvcState_template& state);
extern alt_status as__ns__common__status_instance();
extern void as__ns__common__status();
extern Default_Base *activate_as__ns__common__status();
extern alt_status as__ns__common_instance();
extern void as__ns__common();
extern Default_Base *activate_as__ns__common();
extern void gen__sns__ip__elems(NS__Types::IP4__Elements_template& v4__out, NS__Types::IP6__Elements_template& v6__out);
extern void start_gen__sns__ip__elems(const COMPONENT& component_reference, NS__Types::IP4__Elements_template& v4__out, NS__Types::IP6__Elements_template& v6__out);
extern void f__broadcast__ns__ctrl(const NsCtrlRequest_template& req);
extern void start_f__broadcast__ns__ctrl(const COMPONENT& component_reference, const NsCtrlRequest_template& req);
extern void f__sns__outbound__size__config(const INTEGER& idx);
extern void start_f__sns__outbound__size__config(const COMPONENT& component_reference, const INTEGER& idx);
extern alt_status as__vcg__sns__pcu_instance();
extern void as__vcg__sns__pcu();
extern Default_Base *activate_as__vcg__sns__pcu();
extern alt_status as__vcg__sns__sgsn_instance();
extern void as__vcg__sns__sgsn();
extern Default_Base *activate_as__vcg__sns__sgsn();
extern void NSVCStart(const NSVCConfiguration& init__config, const NSConfiguration& init__g__config, const CHARSTRING& id, const COMPONENT& nsp__ip);
extern void start_NSVCStart(const COMPONENT& component_reference, const NSVCConfiguration& init__config, const NSConfiguration& init__g__config, const CHARSTRING& id, const COMPONENT& nsp__ip);
extern void f__init(const CHARSTRING& id, const COMPONENT& nsp__ip);
extern void start_f__init(const COMPONENT& component_reference, const CHARSTRING& id, const COMPONENT& nsp__ip);
extern void f__change__state(const NsvcState& new__state);
extern void start_f__change__state(const COMPONENT& component_reference, const NsvcState& new__state);
extern void f__sendReset();
extern void start_f__sendReset(const COMPONENT& component_reference);
extern void f__sendAlive();
extern void start_f__sendAlive(const COMPONENT& component_reference);
extern void f__sendUnblock();
extern void start_f__sendUnblock(const COMPONENT& component_reference);
extern void f__sendBlock(const Osmocom__Gb__Types::NsCause& cause);
extern void start_f__sendBlock(const COMPONENT& component_reference, const Osmocom__Gb__Types::NsCause& cause);
extern alt_status as__allstate_instance();
extern void as__allstate();
extern Default_Base *activate_as__allstate();
extern alt_status as__disabled_instance();
extern void as__disabled();
extern Default_Base *activate_as__disabled();
extern alt_status as__handle__reset_instance();
extern void as__handle__reset();
extern Default_Base *activate_as__handle__reset();
extern alt_status as__nsvc__sns_instance();
extern void as__nsvc__sns();
extern Default_Base *activate_as__nsvc__sns();
extern alt_status as__alive__blocked_instance();
extern void as__alive__blocked();
extern Default_Base *activate_as__alive__blocked();
extern alt_status as__alive__unblocked_instance();
extern void as__alive__unblocked();
extern Default_Base *activate_as__alive__unblocked();
extern alt_status as__alive__unblocked__data_instance();
extern void as__alive__unblocked__data();
extern Default_Base *activate_as__alive__unblocked__data();
extern alt_status as__alive__unblocked__sig_instance();
extern void as__alive__unblocked__sig();
extern Default_Base *activate_as__alive__unblocked__sig();
extern alt_status as__wait__reset_instance();
extern void as__wait__reset();
extern Default_Base *activate_as__wait__reset();
extern void f__ScanEvents();
extern void start_f__ScanEvents(const COMPONENT& component_reference);
extern void pre_init_module();
extern void post_init_module();
extern boolean init_comp_type(const char *component_type, boolean init_base_comps);
extern boolean init_system_port(const char* component_type, const char* port_name);
extern boolean start_ptc_function(const char *function_name, Text_Buf& function_arguments);

/* Global variable declarations */

extern const XERdescriptor_t NsUnitdataRequest_bvci_xer_;
extern const TTCN_OERdescriptor_t NsUnitdataRequest_bvci_oer_;
extern const TTCN_Typedescriptor_t NsUnitdataRequest_bvci_descr_;
extern UNIVERSAL_CHARSTRING NsUnitdataRequest_bvci_default_coding;
extern const XERdescriptor_t NsUnitdataRequest_nsei_xer_;
extern const TTCN_OERdescriptor_t NsUnitdataRequest_nsei_oer_;
extern const TTCN_Typedescriptor_t NsUnitdataRequest_nsei_descr_;
extern UNIVERSAL_CHARSTRING NsUnitdataRequest_nsei_default_coding;
extern const XERdescriptor_t NsUnitdataRequest_lsp_xer_;
extern const TTCN_Typedescriptor_t NsUnitdataRequest_lsp_descr_;
extern const TTCN_Typedescriptor_t NsUnitdataRequest_descr_;
extern const XERdescriptor_t NsUnitdataRequest_sdu_xer_;
extern const TTCN_OERdescriptor_t NsUnitdataRequest_sdu_oer_;
extern const TTCN_Typedescriptor_t NsUnitdataRequest_sdu_descr_;
extern UNIVERSAL_CHARSTRING NsUnitdataRequest_bssgp_default_coding;
extern const XERdescriptor_t NsUnitdataIndication_bvci_xer_;
extern const TTCN_OERdescriptor_t NsUnitdataIndication_bvci_oer_;
extern const TTCN_Typedescriptor_t NsUnitdataIndication_bvci_descr_;
extern UNIVERSAL_CHARSTRING NsUnitdataIndication_bvci_default_coding;
extern const XERdescriptor_t NsUnitdataIndication_nsei_xer_;
extern const TTCN_OERdescriptor_t NsUnitdataIndication_nsei_oer_;
extern const TTCN_Typedescriptor_t NsUnitdataIndication_nsei_descr_;
extern UNIVERSAL_CHARSTRING NsUnitdataIndication_nsei_default_coding;
extern const XERdescriptor_t NsUnitdataIndication_nsvci_xer_;
extern const TTCN_OERdescriptor_t NsUnitdataIndication_nsvci_oer_;
extern const TTCN_Typedescriptor_t NsUnitdataIndication_nsvci_descr_;
extern UNIVERSAL_CHARSTRING NsUnitdataIndication_nsvci_default_coding;
extern const TTCN_Typedescriptor_t NsUnitdataIndication_descr_;
extern const XERdescriptor_t NsUnitdataIndication_sdu_xer_;
extern const TTCN_OERdescriptor_t NsUnitdataIndication_sdu_oer_;
extern const TTCN_Typedescriptor_t NsUnitdataIndication_sdu_descr_;
extern UNIVERSAL_CHARSTRING NsUnitdataIndication_bssgp_default_coding;
extern const XERdescriptor_t NsStatusIndication_nsei_xer_;
extern const TTCN_OERdescriptor_t NsStatusIndication_nsei_oer_;
extern const TTCN_Typedescriptor_t NsStatusIndication_nsei_descr_;
extern UNIVERSAL_CHARSTRING NsStatusIndication_nsei_default_coding;
extern const XERdescriptor_t NsStatusIndication_nsvci_xer_;
extern const TTCN_OERdescriptor_t NsStatusIndication_nsvci_oer_;
extern const TTCN_Typedescriptor_t NsStatusIndication_nsvci_descr_;
extern UNIVERSAL_CHARSTRING NsStatusIndication_nsvci_default_coding;
extern const TTCN_Typedescriptor_t NsvcState_descr_;
extern const XERdescriptor_t NsStatusIndication_first__or__last_xer_;
extern const TTCN_OERdescriptor_t NsStatusIndication_first__or__last_oer_;
extern const TTCN_Typedescriptor_t NsStatusIndication_first__or__last_descr_;
extern const TTCN_Typedescriptor_t NsStatusIndication_descr_;
extern const INTEGER_template& tr__NsStsInd_nsei_defval;
extern INTEGER_template template_tr__NsStsInd_nsei_defval;
extern const INTEGER_template& tr__NsStsInd_nsvci_defval;
extern INTEGER_template template_tr__NsStsInd_nsvci_defval;
extern const NsvcState_template& tr__NsStsInd_old__state_defval;
extern NsvcState_template template_tr__NsStsInd_old__state_defval;
extern const NsvcState_template& tr__NsStsInd_state_defval;
extern NsvcState_template template_tr__NsStsInd_state_defval;
extern const BOOLEAN_template& tr__NsStsInd_first__or__last_defval;
extern BOOLEAN_template template_tr__NsStsInd_first__or__last_defval;
extern const BOOLEAN& ts__NsStsInd_first__or__last_defval;
extern BOOLEAN const_ts__NsStsInd_first__or__last_defval;
extern const XERdescriptor_t NsDisableVcRequest_nsvci_xer_;
extern const TTCN_OERdescriptor_t NsDisableVcRequest_nsvci_oer_;
extern const TTCN_Typedescriptor_t NsDisableVcRequest_nsvci_descr_;
extern UNIVERSAL_CHARSTRING NsDisableVcRequest_nsvci_default_coding;
extern const TTCN_Typedescriptor_t NsDisableVcRequest_descr_;
extern const XERdescriptor_t NsEnableVcRequest_nsvci_xer_;
extern const TTCN_OERdescriptor_t NsEnableVcRequest_nsvci_oer_;
extern const TTCN_Typedescriptor_t NsEnableVcRequest_nsvci_descr_;
extern UNIVERSAL_CHARSTRING NsEnableVcRequest_nsvci_default_coding;
extern const TTCN_Typedescriptor_t NsEnableVcRequest_descr_;
extern const TTCN_Typedescriptor_t& NS__Provider__CT_descr_;
extern NS__PROVIDER__PT NS__Provider__CT_component_NSE;
extern const TTCN_Typedescriptor_t NS__Provider__LinkStatus_descr_;
extern const TTCN_Typedescriptor_t NS__Provider__Evt_descr_;
extern UNIVERSAL_CHARSTRING NSVCConfigurationIP_address__family_default_coding;
extern const XERdescriptor_t NSVCConfigurationIP_local__udp__port_xer_;
extern const TTCN_OERdescriptor_t NSVCConfigurationIP_local__udp__port_oer_;
extern const TTCN_Typedescriptor_t NSVCConfigurationIP_local__udp__port_descr_;
extern const XERdescriptor_t NSVCConfigurationIP_local__ip_xer_;
extern const TTCN_Typedescriptor_t NSVCConfigurationIP_local__ip_descr_;
extern const XERdescriptor_t NSVCConfigurationIP_remote__udp__port_xer_;
extern const TTCN_OERdescriptor_t NSVCConfigurationIP_remote__udp__port_oer_;
extern const TTCN_Typedescriptor_t NSVCConfigurationIP_remote__udp__port_descr_;
extern const XERdescriptor_t NSVCConfigurationIP_remote__ip_xer_;
extern const TTCN_Typedescriptor_t NSVCConfigurationIP_remote__ip_descr_;
extern const XERdescriptor_t NSVCConfigurationIP_data__weight_xer_;
extern const TTCN_OERdescriptor_t NSVCConfigurationIP_data__weight_oer_;
extern const TTCN_Typedescriptor_t NSVCConfigurationIP_data__weight_descr_;
extern UNIVERSAL_CHARSTRING NSVCConfigurationIP_data__weight_default_coding;
extern const XERdescriptor_t NSVCConfigurationIP_signalling__weight_xer_;
extern const TTCN_OERdescriptor_t NSVCConfigurationIP_signalling__weight_oer_;
extern const TTCN_Typedescriptor_t NSVCConfigurationIP_signalling__weight_descr_;
extern UNIVERSAL_CHARSTRING NSVCConfigurationIP_signalling__weight_default_coding;
extern const TTCN_Typedescriptor_t NSVCConfigurationIP_descr_;
extern const XERdescriptor_t NSVCConfigurationFR_netdev_xer_;
extern const TTCN_Typedescriptor_t NSVCConfigurationFR_netdev_descr_;
extern const XERdescriptor_t NSVCConfigurationFR_dlci_xer_;
extern const TTCN_Typedescriptor_t NSVCConfigurationFR_dlci_descr_;
extern const TTCN_Typedescriptor_t NSVCConfigurationFR_descr_;
extern const TTCN_Typedescriptor_t NSVCConfigurationP_descr_;
extern const XERdescriptor_t NSVCConfiguration_nsvci_xer_;
extern const TTCN_OERdescriptor_t NSVCConfiguration_nsvci_oer_;
extern const TTCN_Typedescriptor_t NSVCConfiguration_nsvci_descr_;
extern UNIVERSAL_CHARSTRING NSVCConfiguration_nsvci_default_coding;
extern const TTCN_Typedescriptor_t NSVCConfiguration_descr_;
extern const TTCN_Typedescriptor_t NSVCConfigurations_descr_;
extern const XERdescriptor_t NSConfiguration_nsei_xer_;
extern const TTCN_OERdescriptor_t NSConfiguration_nsei_oer_;
extern const TTCN_Typedescriptor_t NSConfiguration_nsei_descr_;
extern UNIVERSAL_CHARSTRING NSConfiguration_nsei_default_coding;
extern const XERdescriptor_t NSConfiguration_role__sgsn_xer_;
extern const TTCN_OERdescriptor_t NSConfiguration_role__sgsn_oer_;
extern const TTCN_Typedescriptor_t NSConfiguration_role__sgsn_descr_;
extern const XERdescriptor_t NSConfiguration_handle__sns_xer_;
extern const TTCN_OERdescriptor_t NSConfiguration_handle__sns_oer_;
extern const TTCN_Typedescriptor_t NSConfiguration_handle__sns_descr_;
extern const TTCN_Typedescriptor_t NSConfiguration_descr_;
extern const TTCN_Typedescriptor_t& NS__CT_descr_;
extern NS__SP__PT NS__CT_component_NS__SP;
extern NSint__PT NS__CT_component_NSVC;
extern NS__CTRL__SP__PT NS__CT_component_NS__CTRL;
extern NSConfiguration NS__CT_component_g__config;
extern CHARSTRING NS__CT_component_g__id;
extern const TTCN_Typedescriptor_t IpEndpointTable_descr_;
extern UNIVERSAL_CHARSTRING IpEndpointTableEntry_address__family_default_coding;
extern const XERdescriptor_t IpEndpointTableEntry_local__udp__port_xer_;
extern const TTCN_OERdescriptor_t IpEndpointTableEntry_local__udp__port_oer_;
extern const TTCN_Typedescriptor_t IpEndpointTableEntry_local__udp__port_descr_;
extern const XERdescriptor_t IpEndpointTableEntry_local__ip_xer_;
extern const TTCN_Typedescriptor_t IpEndpointTableEntry_local__ip_descr_;
extern const XERdescriptor_t IpEndpointTableEntry_data__weight_xer_;
extern const TTCN_OERdescriptor_t IpEndpointTableEntry_data__weight_oer_;
extern const TTCN_Typedescriptor_t IpEndpointTableEntry_data__weight_descr_;
extern UNIVERSAL_CHARSTRING IpEndpointTableEntry_data__weight_default_coding;
extern const XERdescriptor_t IpEndpointTableEntry_signalling__weight_xer_;
extern const TTCN_OERdescriptor_t IpEndpointTableEntry_signalling__weight_oer_;
extern const TTCN_Typedescriptor_t IpEndpointTableEntry_signalling__weight_descr_;
extern UNIVERSAL_CHARSTRING IpEndpointTableEntry_signalling__weight_default_coding;
extern const TTCN_Typedescriptor_t IpEndpointTableEntry_descr_;
extern IpEndpointTable NS__CT_component_g__ip__endpoints;
extern NS__Provider__IPL4::NSPIP__PROC__PT NS__CT_component_NSPIP__PROC;
extern const TTCN_Typedescriptor_t NsvcTable_descr_;
extern const TTCN_Typedescriptor_t& NSVC__CT_descr_;
extern const TTCN_Typedescriptor_t NsvcTableEntry_descr_;
extern NsvcTable NS__CT_component_g__nsvcs;
extern Osmocom__Types::ro__integer NS__CT_component_g__unblocked__nsvcs__sig;
extern Osmocom__Types::ro__integer NS__CT_component_g__unblocked__nsvcs__data;
extern const XERdescriptor_t SnsIndication_nsvci_xer_;
extern const TTCN_OERdescriptor_t SnsIndication_nsvci_oer_;
extern const TTCN_Typedescriptor_t SnsIndication_nsvci_descr_;
extern UNIVERSAL_CHARSTRING SnsIndication_nsvci_default_coding;
extern UNIVERSAL_CHARSTRING SnsIndication_ns_default_coding;
extern const TTCN_Typedescriptor_t SnsIndication_descr_;
extern const XERdescriptor_t SnsRequest_nsvci_xer_;
extern const TTCN_OERdescriptor_t SnsRequest_nsvci_oer_;
extern const TTCN_Typedescriptor_t SnsRequest_nsvci_descr_;
extern UNIVERSAL_CHARSTRING SnsRequest_nsvci_default_coding;
extern UNIVERSAL_CHARSTRING SnsRequest_ns_default_coding;
extern const TTCN_Typedescriptor_t SnsRequest_descr_;
extern const TTCN_Typedescriptor_t NsCtrlRequest_descr_;
extern const CHARSTRING& NSStart_id_defval;
extern CHARSTRING const_NSStart_id_defval;
extern const NsvcState_template& f__count__nsvcs__in__state_state_defval;
extern NsvcState_template template_f__count__nsvcs__in__state_state_defval;
extern const INTEGER& f__sns__outbound__size__config_idx_defval;
extern INTEGER const_f__sns__outbound__size__config_idx_defval;
extern NS__PROVIDER__PT NSVC__CT_component_NSCP;
extern COMPONENT NSVC__CT_component_vc__NSP__IP;
extern COMPONENT NSVC__CT_component_vc__NSP__FR;
extern NSint__SP__PT NSVC__CT_component_NS__SP;
extern NSVCConfiguration NSVC__CT_component_g__nsvc__config;
extern NSConfiguration NSVC__CT_component_g__config;
extern NsvcState NSVC__CT_component_vc__state;
extern TIMER NSVC__CT_component_Tns__alive;
extern TIMER NSVC__CT_component_Tns__test;
extern TIMER NSVC__CT_component_Tns__block;
extern TIMER NSVC__CT_component_Tns__reset;
extern const CHARSTRING& NSVCStart_id_defval;
extern CHARSTRING const_NSVCStart_id_defval;
extern const COMPONENT& NSVCStart_nsp__ip_defval;
extern COMPONENT const_NSVCStart_nsp__ip_defval;
extern const CHARSTRING cs_0,
cs_3,
cs_4,
cs_1,
cs_2,
cs_5;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
