// This C++ header file was generated by the TTCN-3 compiler
// of the TTCN-3 Test Executor version 9.0.0
// for  (build@df34402ede0d) on Tue Jun 25 17:59:45 2024

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

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

#ifndef PFCP__Emulation_HH
#define PFCP__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_Types.hh"
#include "PFCP_CodecPort_CtrlFunct.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 PFCP__Emulation_HH
#endif

namespace PFCP__Emulation {

/* Forward declarations of classes */

class PFCP__Role;
class PFCP__Role_template;
class PFCP__Emulation__Cfg;
class PFCP__Emulation__Cfg_template;
class PFCPEM__conns;
class PFCPEM__conns_template;
class PFCPEM__conn;
class PFCPEM__conn_template;
class PFCPEM__PT;
class PFCPEM__register_call;
class PFCPEM__register_call_redirect;
class PFCPEM__register_reply;
class PFCPEM__register_reply_redirect;
class PFCPEM__register_template;
class PFCPEM__PROC__PT;

} /* end of namespace */

#ifndef PFCP__Emulation_HH
#define PFCP__Emulation_HH

namespace PFCP__Emulation {

/* Type definitions */

typedef COMPONENT PFCP__Emulation__CT;
typedef COMPONENT_template PFCP__Emulation__CT_template;
typedef COMPONENT PFCP__ConnHdlr;
typedef COMPONENT_template PFCP__ConnHdlr_template;

/* Class definitions */

class PFCP__Role : public Base_Type { // enum
friend class PFCP__Role_template;
public:
enum enum_type { CPF = 0, UPF = 1, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

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

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

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

void copy_template(const PFCP__Role_template& other_value);

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

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

boolean match(PFCP__Role::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const PFCP__Role& other_value, boolean legacy = FALSE) const;
PFCP__Role::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PFCP__Role_template& list_item(unsigned int list_index);
void log() const;
void log_match(const PFCP__Role& 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 PFCP__Emulation__Cfg {
  CHARSTRING field_pfcp__bind__ip;
  INTEGER field_pfcp__bind__port;
  CHARSTRING field_pfcp__remote__ip;
  INTEGER field_pfcp__remote__port;
  PFCP__Role field_role;
public:
  PFCP__Emulation__Cfg();
  PFCP__Emulation__Cfg(const CHARSTRING& par_pfcp__bind__ip,
    const INTEGER& par_pfcp__bind__port,
    const CHARSTRING& par_pfcp__remote__ip,
    const INTEGER& par_pfcp__remote__port,
    const PFCP__Role& par_role);
  PFCP__Emulation__Cfg(const PFCP__Emulation__Cfg& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PFCP__Emulation__Cfg& operator=(const PFCP__Emulation__Cfg& other_value);
  boolean operator==(const PFCP__Emulation__Cfg& other_value) const;
  inline boolean operator!=(const PFCP__Emulation__Cfg& 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& pfcp__bind__ip()
    {return field_pfcp__bind__ip;}
  inline const CHARSTRING& pfcp__bind__ip() const
    {return field_pfcp__bind__ip;}
  inline INTEGER& pfcp__bind__port()
    {return field_pfcp__bind__port;}
  inline const INTEGER& pfcp__bind__port() const
    {return field_pfcp__bind__port;}
  inline CHARSTRING& pfcp__remote__ip()
    {return field_pfcp__remote__ip;}
  inline const CHARSTRING& pfcp__remote__ip() const
    {return field_pfcp__remote__ip;}
  inline INTEGER& pfcp__remote__port()
    {return field_pfcp__remote__port;}
  inline const INTEGER& pfcp__remote__port() const
    {return field_pfcp__remote__port;}
  inline PFCP__Role& role()
    {return field_role;}
  inline const PFCP__Role& role() const
    {return field_role;}
  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 PFCP__Emulation__Cfg_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
PFCP__Emulation__Cfg_template *list_value;
} value_list;
struct {
PFCP__Emulation__Cfg_template* precondition;
PFCP__Emulation__Cfg_template* implied_template;
} implication_;
dynmatch_struct<PFCP__Emulation__Cfg>* dyn_match;
};

void set_specific();
void copy_value(const PFCP__Emulation__Cfg& other_value);
void copy_template(const PFCP__Emulation__Cfg_template& other_value);

public:
PFCP__Emulation__Cfg_template();
PFCP__Emulation__Cfg_template(template_sel other_value);
PFCP__Emulation__Cfg_template(const PFCP__Emulation__Cfg& other_value);
PFCP__Emulation__Cfg_template(const OPTIONAL<PFCP__Emulation__Cfg>& other_value);
PFCP__Emulation__Cfg_template(PFCP__Emulation__Cfg_template* p_precondition, PFCP__Emulation__Cfg_template* p_implied_template);
PFCP__Emulation__Cfg_template(Dynamic_Match_Interface<PFCP__Emulation__Cfg>* p_dyn_match);
PFCP__Emulation__Cfg_template(const PFCP__Emulation__Cfg_template& other_value);
~PFCP__Emulation__Cfg_template();
PFCP__Emulation__Cfg_template& operator=(template_sel other_value);
PFCP__Emulation__Cfg_template& operator=(const PFCP__Emulation__Cfg& other_value);
PFCP__Emulation__Cfg_template& operator=(const OPTIONAL<PFCP__Emulation__Cfg>& other_value);
PFCP__Emulation__Cfg_template& operator=(const PFCP__Emulation__Cfg_template& other_value);
boolean match(const PFCP__Emulation__Cfg& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PFCP__Emulation__Cfg valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PFCP__Emulation__Cfg_template& list_item(unsigned int list_index) const;
CHARSTRING_template& pfcp__bind__ip();
const CHARSTRING_template& pfcp__bind__ip() const;
INTEGER_template& pfcp__bind__port();
const INTEGER_template& pfcp__bind__port() const;
CHARSTRING_template& pfcp__remote__ip();
const CHARSTRING_template& pfcp__remote__ip() const;
INTEGER_template& pfcp__remote__port();
const INTEGER_template& pfcp__remote__port() const;
PFCP__Role_template& role();
const PFCP__Role_template& role() const;
int size_of() const;
void log() const;
void log_match(const PFCP__Emulation__Cfg& 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 PFCPEM__conns : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
PFCPEM__conn **value_elements;
} *val_ptr;

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

public:
  typedef PFCPEM__conn of_type;
PFCPEM__conns();
PFCPEM__conns(null_type other_value);
PFCPEM__conns(const PFCPEM__conns& other_value);
~PFCPEM__conns();

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

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

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

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

PFCPEM__conns operator+(const PFCPEM__conns& other_value) const;

PFCPEM__conns substr(int index, int returncount) const;

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

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

void clean_up();
PFCPEM__conns_template& operator=(template_sel other_value);
PFCPEM__conns_template& operator=(null_type other_value);
PFCPEM__conns_template& operator=(const PFCPEM__conns& other_value);
PFCPEM__conns_template& operator=(const OPTIONAL<PFCPEM__conns>& other_value);
PFCPEM__conns_template& operator=(const PFCPEM__conns_template& other_value);

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

PFCPEM__conns replace(int index, int len, const PFCPEM__conns_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
PFCPEM__conns_template& list_item(unsigned int list_index);
void log() const;
void log_match(const PFCPEM__conns& 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 PFCPEM__conn {
  COMPONENT field_vc__conn;
  OPTIONAL< OCTETSTRING > field_seid;
  OPTIONAL< INTEGER > field_pfcp__msg__sequence__number;
public:
  PFCPEM__conn();
  PFCPEM__conn(const COMPONENT& par_vc__conn,
    const OPTIONAL< OCTETSTRING >& par_seid,
    const OPTIONAL< INTEGER >& par_pfcp__msg__sequence__number);
  PFCPEM__conn(const PFCPEM__conn& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PFCPEM__conn& operator=(const PFCPEM__conn& other_value);
  boolean operator==(const PFCPEM__conn& other_value) const;
  inline boolean operator!=(const PFCPEM__conn& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline COMPONENT& vc__conn()
    {return field_vc__conn;}
  inline const COMPONENT& vc__conn() const
    {return field_vc__conn;}
  inline OPTIONAL< OCTETSTRING >& seid()
    {return field_seid;}
  inline const OPTIONAL< OCTETSTRING >& seid() const
    {return field_seid;}
  inline OPTIONAL< INTEGER >& pfcp__msg__sequence__number()
    {return field_pfcp__msg__sequence__number;}
  inline const OPTIONAL< INTEGER >& pfcp__msg__sequence__number() const
    {return field_pfcp__msg__sequence__number;}
  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 PFCPEM__conn_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
PFCPEM__conn_template *list_value;
} value_list;
struct {
PFCPEM__conn_template* precondition;
PFCPEM__conn_template* implied_template;
} implication_;
dynmatch_struct<PFCPEM__conn>* dyn_match;
};

void set_specific();
void copy_value(const PFCPEM__conn& other_value);
void copy_template(const PFCPEM__conn_template& other_value);

public:
PFCPEM__conn_template();
PFCPEM__conn_template(template_sel other_value);
PFCPEM__conn_template(const PFCPEM__conn& other_value);
PFCPEM__conn_template(const OPTIONAL<PFCPEM__conn>& other_value);
PFCPEM__conn_template(PFCPEM__conn_template* p_precondition, PFCPEM__conn_template* p_implied_template);
PFCPEM__conn_template(Dynamic_Match_Interface<PFCPEM__conn>* p_dyn_match);
PFCPEM__conn_template(const PFCPEM__conn_template& other_value);
~PFCPEM__conn_template();
PFCPEM__conn_template& operator=(template_sel other_value);
PFCPEM__conn_template& operator=(const PFCPEM__conn& other_value);
PFCPEM__conn_template& operator=(const OPTIONAL<PFCPEM__conn>& other_value);
PFCPEM__conn_template& operator=(const PFCPEM__conn_template& other_value);
boolean match(const PFCPEM__conn& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PFCPEM__conn valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PFCPEM__conn_template& list_item(unsigned int list_index) const;
COMPONENT_template& vc__conn();
const COMPONENT_template& vc__conn() const;
OCTETSTRING_template& seid();
const OCTETSTRING_template& seid() const;
INTEGER_template& pfcp__msg__sequence__number();
const INTEGER_template& pfcp__msg__sequence__number() const;
int size_of() const;
void log() const;
void log_match(const PFCPEM__conn& 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 PFCPEM__PT : public PORT {
enum msg_selection { MESSAGE_0 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
PFCP__Types::PDU__PFCP *message_0;
};
component sender_component;
};

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

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

class PFCPEM__register_call_redirect {
public:
inline void set_parameters(const PFCPEM__register_call&) const { }
};

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

class PFCPEM__register_reply_redirect {
public:
inline void set_parameters(const PFCPEM__register_reply&) const {}
};

class PFCPEM__register_template {
public:
PFCPEM__register_template() { }
PFCPEM__register_template(null_type) { }
inline PFCPEM__register_template& operator=(null_type) { return *this; }
inline PFCPEM__register_call create_call() const { return PFCPEM__register_call(); }
inline PFCPEM__register_reply create_reply() const { return PFCPEM__register_reply(); }
inline boolean match_call(const PFCPEM__register_call&, boolean legacy = FALSE) const { return TRUE; }
inline boolean match_reply(const PFCPEM__register_reply&, boolean legacy = FALSE) const { return TRUE; }
void log() const;
void log_match_call(const PFCPEM__register_call& match_value, boolean legacy = FALSE) const;
void log_match_reply(const PFCPEM__register_reply& match_value, boolean legacy = FALSE) const;
inline void encode_text(Text_Buf&) const { }
inline void decode_text(Text_Buf&) { }
};

class PFCPEM__PROC__PT : public PORT {
enum proc_selection { CALL_0, REPLY_0 };
struct proc_queue_item {
proc_selection item_selection;
union {
PFCPEM__register_call *call_0;
PFCPEM__register_reply *reply_0;
};
component sender_component;
proc_queue_item *next_item;
} *proc_queue_head, *proc_queue_tail;
void append_to_proc_queue(proc_queue_item *new_item);
void remove_proc_queue_head();
protected:
void clear_queue();
public:
PFCPEM__PROC__PT(const char *par_port_name = NULL);
~PFCPEM__PROC__PT();
void call(const PFCPEM__register_template& call_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void call(const PFCPEM__register_template& call_template, FLOAT* timestamp_redirect = NULL);
void reply(const PFCPEM__register_template& reply_template, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void reply(const PFCPEM__register_template& reply_template, FLOAT* timestamp_redirect = NULL);
public:
alt_status getcall(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getcall(const PFCPEM__register_template& getcall_template, const COMPONENT_template& sender_template, const PFCPEM__register_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getcall(const PFCPEM__register_template& getcall_template, const COMPONENT_template& sender_template, const PFCPEM__register_call_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status getreply(const PFCPEM__register_template& getreply_template, const COMPONENT_template& sender_template, const PFCPEM__register_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_getreply(const PFCPEM__register_template& getreply_template, const COMPONENT_template& sender_template, const PFCPEM__register_reply_redirect& param_ref, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_call(const PFCPEM__register_call& incoming_par, component sender_component);
void incoming_reply(const PFCPEM__register_reply& incoming_par, component sender_component);
protected:
boolean process_call(const char *signature_name, Text_Buf& incoming_buf, component sender_component);
boolean process_reply(const char *signature_name, Text_Buf& incoming_buf, component sender_component);
};


/* Function prototypes */

extern boolean operator==(null_type null_value, const PFCPEM__conns& other_value);
inline boolean operator!=(null_type null_value, const PFCPEM__conns& other_value) { return !(null_value == other_value); }
extern INTEGER f__PFCPEM__next__sequence__nr();
extern void start_f__PFCPEM__next__sequence__nr(const COMPONENT& component_reference);
extern COMPONENT f__PFCPEM__conn__by__seid__or__seqnr(const OCTETSTRING& seid, const INTEGER& seqnr);
extern void start_f__PFCPEM__conn__by__seid__or__seqnr(const COMPONENT& component_reference, const OCTETSTRING& seid, const INTEGER& seqnr);
extern void f__PFCPEM__add__conn(const COMPONENT& vc__conn);
extern void start_f__PFCPEM__add__conn(const COMPONENT& component_reference, const COMPONENT& vc__conn);
extern void f__init(const PFCP__Emulation__Cfg& cfg);
extern void start_f__init(const COMPONENT& component_reference, const PFCP__Emulation__Cfg& cfg);
extern void main_(const PFCP__Emulation__Cfg& cfg);
extern void start_main_(const COMPONENT& component_reference, const PFCP__Emulation__Cfg& cfg);
extern void f__pfcp__register();
extern void start_f__pfcp__register(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 INTEGER& PFCP__PORT;
extern INTEGER const_PFCP__PORT;
extern const TTCN_Typedescriptor_t PFCP__Role_descr_;
extern const XERdescriptor_t PFCP__Emulation__Cfg_pfcp__bind__ip_xer_;
extern const TTCN_Typedescriptor_t PFCP__Emulation__Cfg_pfcp__bind__ip_descr_;
extern const XERdescriptor_t PFCP__Emulation__Cfg_pfcp__bind__port_xer_;
extern const TTCN_OERdescriptor_t PFCP__Emulation__Cfg_pfcp__bind__port_oer_;
extern const TTCN_Typedescriptor_t PFCP__Emulation__Cfg_pfcp__bind__port_descr_;
extern const XERdescriptor_t PFCP__Emulation__Cfg_pfcp__remote__ip_xer_;
extern const TTCN_Typedescriptor_t PFCP__Emulation__Cfg_pfcp__remote__ip_descr_;
extern const XERdescriptor_t PFCP__Emulation__Cfg_pfcp__remote__port_xer_;
extern const TTCN_OERdescriptor_t PFCP__Emulation__Cfg_pfcp__remote__port_oer_;
extern const TTCN_Typedescriptor_t PFCP__Emulation__Cfg_pfcp__remote__port_descr_;
extern const TTCN_Typedescriptor_t PFCP__Emulation__Cfg_descr_;
extern const TTCN_Typedescriptor_t& PFCP__Emulation__CT_descr_;
extern PFCP__CodecPort::PFCP__PT PFCP__Emulation__CT_component_PFCP;
extern PFCPEM__PT PFCP__Emulation__CT_component_CLIENT;
extern PFCPEM__PROC__PT PFCP__Emulation__CT_component_CLIENT__PROC;
extern PFCP__Emulation__Cfg PFCP__Emulation__CT_component_g__pfcp__cfg;
extern INTEGER PFCP__Emulation__CT_component_g__pfcp__conn__id;
extern INTEGER PFCP__Emulation__CT_component_g__recovery__timestamp;
extern const TTCN_Typedescriptor_t PFCPEM__conns_descr_;
extern const TTCN_Typedescriptor_t& PFCP__ConnHdlr_descr_;
extern const TTCN_Typedescriptor_t PFCPEM__conn_descr_;
extern const XERdescriptor_t PFCPEM__conn_seid_xer_;
extern const TTCN_OERdescriptor_t PFCPEM__conn_seid_oer_;
extern const TTCN_Typedescriptor_t PFCPEM__conn_seid_descr_;
extern UNIVERSAL_CHARSTRING PFCPEM__conn_seid_default_coding;
extern const XERdescriptor_t PFCPEM__conn_pfcp__msg__sequence__number_xer_;
extern const TTCN_OERdescriptor_t PFCPEM__conn_pfcp__msg__sequence__number_oer_;
extern const TTCN_Typedescriptor_t PFCPEM__conn_pfcp__msg__sequence__number_descr_;
extern UNIVERSAL_CHARSTRING PFCPEM__conn_pfcp__msg__sequence__number_default_coding;
extern PFCPEM__conns PFCP__Emulation__CT_component_g__conns;
extern INTEGER PFCP__Emulation__CT_component_g__next__sequence__nr__state;
extern PFCPEM__PT PFCP__ConnHdlr_component_PFCP;
extern PFCPEM__PROC__PT PFCP__ConnHdlr_component_PFCP__PROC;
extern COMPONENT PFCP__ConnHdlr_component_vc__PFCP;
extern const BITSTRING bs_0;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif