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

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

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

#ifndef UD__Types_HH
#define UD__Types_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 "Socket_API_Definitions.hh"

#if TTCN3_VERSION != 110100
#error Version mismatch detected.\
 Please check the version of the TTCN-3 compiler and the base library.\
 Run make clean and rebuild the project if the version of the compiler changed recently.
#endif

#ifndef LINUX
#error This file should be compiled on LINUX
#endif

#undef UD__Types_HH
#endif

namespace UD__Types {

/* Forward declarations of classes */

class UD__Result__code;
class UD__Result__code_template;
class UD__Result;
class UD__Result_template;
class UD__close;
class UD__close_template;
class UD__connect;
class UD__connect_template;
class UD__connect__result;
class UD__connect__result_template;
class UD__send__data;
class UD__send__data_template;
class UD__connected;
class UD__connected_template;
class UD__listen;
class UD__listen_template;
class UD__listen__result;
class UD__listen__result_template;
class UD__shutdown;
class UD__shutdown_template;

} /* end of namespace */

#ifndef UD__Types_HH
#define UD__Types_HH

namespace UD__Types {

/* Type definitions */

typedef Socket__API__Definitions::ro__integer ro__integer;
typedef Socket__API__Definitions::ro__integer_template ro__integer_template;
typedef Socket__API__Definitions::f__getMsgLen f__getMsgLen;
typedef Socket__API__Definitions::f__getMsgLen_template f__getMsgLen_template;
typedef Socket__API__Definitions::f__getMsgLen f__UD__getMsgLen;
typedef Socket__API__Definitions::f__getMsgLen_template f__UD__getMsgLen_template;
typedef OCTETSTRING PDU__UD;
typedef OCTETSTRING_template PDU__UD_template;
typedef CHARSTRING Path;
typedef CHARSTRING_template Path_template;

/* Class definitions */

class UD__Result__code : public Base_Type { // enum
friend class UD__Result__code_template;
public:
enum enum_type { ERROR_ = 0, SUCCESS = 1, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

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

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

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const UD__Result__code& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const UD__Result__code& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const UD__Result__code& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const UD__Result__code& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const UD__Result__code& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const UD__Result__code& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

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

void copy_template(const UD__Result__code_template& other_value);

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

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

boolean match(UD__Result__code::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const UD__Result__code& other_value, boolean legacy = FALSE) const;
UD__Result__code::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
UD__Result__code_template& list_item(unsigned int list_index);
void log() const;
void log_match(const UD__Result__code& 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 UD__Result {
  OPTIONAL< UD__Result__code > field_result__code;
  OPTIONAL< CHARSTRING > field_err;
public:
  UD__Result();
  UD__Result(const OPTIONAL< UD__Result__code >& par_result__code,
    const OPTIONAL< CHARSTRING >& par_err);
  UD__Result(const UD__Result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UD__Result& operator=(const UD__Result& other_value);
  boolean operator==(const UD__Result& other_value) const;
  inline boolean operator!=(const UD__Result& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OPTIONAL< UD__Result__code >& result__code()
    {return field_result__code;}
  inline const OPTIONAL< UD__Result__code >& result__code() const
    {return field_result__code;}
  inline OPTIONAL< CHARSTRING >& err()
    {return field_err;}
  inline const OPTIONAL< CHARSTRING >& err() const
    {return field_err;}
  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 UD__Result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UD__Result_template *list_value;
} value_list;
struct {
UD__Result_template* precondition;
UD__Result_template* implied_template;
} implication_;
dynmatch_struct<UD__Result>* dyn_match;
};

void set_specific();
void copy_value(const UD__Result& other_value);
void copy_template(const UD__Result_template& other_value);

public:
UD__Result_template();
UD__Result_template(template_sel other_value);
UD__Result_template(const UD__Result& other_value);
UD__Result_template(const OPTIONAL<UD__Result>& other_value);
UD__Result_template(UD__Result_template* p_precondition, UD__Result_template* p_implied_template);
UD__Result_template(Dynamic_Match_Interface<UD__Result>* p_dyn_match);
UD__Result_template(const UD__Result_template& other_value);
~UD__Result_template();
UD__Result_template& operator=(template_sel other_value);
UD__Result_template& operator=(const UD__Result& other_value);
UD__Result_template& operator=(const OPTIONAL<UD__Result>& other_value);
UD__Result_template& operator=(const UD__Result_template& other_value);
boolean match(const UD__Result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UD__Result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UD__Result_template& list_item(unsigned int list_index) const;
UD__Result__code_template& result__code();
const UD__Result__code_template& result__code() const;
CHARSTRING_template& err();
const CHARSTRING_template& err() const;
int size_of() const;
void log() const;
void log_match(const UD__Result& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class UD__close {
  INTEGER field_id;
public:
  UD__close();
  UD__close(const INTEGER& par_id);
  UD__close(const UD__close& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UD__close& operator=(const UD__close& other_value);
  boolean operator==(const UD__close& other_value) const;
  inline boolean operator!=(const UD__close& 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& id()
    {return field_id;}
  inline const INTEGER& id() const
    {return field_id;}
  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 UD__close_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UD__close_template *list_value;
} value_list;
struct {
UD__close_template* precondition;
UD__close_template* implied_template;
} implication_;
dynmatch_struct<UD__close>* dyn_match;
};

void set_specific();
void copy_value(const UD__close& other_value);
void copy_template(const UD__close_template& other_value);

public:
UD__close_template();
UD__close_template(template_sel other_value);
UD__close_template(const UD__close& other_value);
UD__close_template(const OPTIONAL<UD__close>& other_value);
UD__close_template(UD__close_template* p_precondition, UD__close_template* p_implied_template);
UD__close_template(Dynamic_Match_Interface<UD__close>* p_dyn_match);
UD__close_template(const UD__close_template& other_value);
~UD__close_template();
UD__close_template& operator=(template_sel other_value);
UD__close_template& operator=(const UD__close& other_value);
UD__close_template& operator=(const OPTIONAL<UD__close>& other_value);
UD__close_template& operator=(const UD__close_template& other_value);
boolean match(const UD__close& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UD__close valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UD__close_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
int size_of() const;
void log() const;
void log_match(const UD__close& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class UD__connect {
  CHARSTRING field_path;
  INTEGER field_id;
public:
  UD__connect();
  UD__connect(const CHARSTRING& par_path,
    const INTEGER& par_id);
  UD__connect(const UD__connect& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UD__connect& operator=(const UD__connect& other_value);
  boolean operator==(const UD__connect& other_value) const;
  inline boolean operator!=(const UD__connect& 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& path()
    {return field_path;}
  inline const CHARSTRING& path() const
    {return field_path;}
  inline INTEGER& id()
    {return field_id;}
  inline const INTEGER& id() const
    {return field_id;}
  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 UD__connect_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UD__connect_template *list_value;
} value_list;
struct {
UD__connect_template* precondition;
UD__connect_template* implied_template;
} implication_;
dynmatch_struct<UD__connect>* dyn_match;
};

void set_specific();
void copy_value(const UD__connect& other_value);
void copy_template(const UD__connect_template& other_value);

public:
UD__connect_template();
UD__connect_template(template_sel other_value);
UD__connect_template(const UD__connect& other_value);
UD__connect_template(const OPTIONAL<UD__connect>& other_value);
UD__connect_template(UD__connect_template* p_precondition, UD__connect_template* p_implied_template);
UD__connect_template(Dynamic_Match_Interface<UD__connect>* p_dyn_match);
UD__connect_template(const UD__connect_template& other_value);
~UD__connect_template();
UD__connect_template& operator=(template_sel other_value);
UD__connect_template& operator=(const UD__connect& other_value);
UD__connect_template& operator=(const OPTIONAL<UD__connect>& other_value);
UD__connect_template& operator=(const UD__connect_template& other_value);
boolean match(const UD__connect& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UD__connect valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UD__connect_template& list_item(unsigned int list_index) const;
CHARSTRING_template& path();
const CHARSTRING_template& path() const;
INTEGER_template& id();
const INTEGER_template& id() const;
int size_of() const;
void log() const;
void log_match(const UD__connect& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class UD__connect__result {
  INTEGER field_id;
  OPTIONAL< UD__Result > field_result;
public:
  UD__connect__result();
  UD__connect__result(const INTEGER& par_id,
    const OPTIONAL< UD__Result >& par_result);
  UD__connect__result(const UD__connect__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UD__connect__result& operator=(const UD__connect__result& other_value);
  boolean operator==(const UD__connect__result& other_value) const;
  inline boolean operator!=(const UD__connect__result& 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& id()
    {return field_id;}
  inline const INTEGER& id() const
    {return field_id;}
  inline OPTIONAL< UD__Result >& result()
    {return field_result;}
  inline const OPTIONAL< UD__Result >& result() const
    {return field_result;}
  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 UD__connect__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UD__connect__result_template *list_value;
} value_list;
struct {
UD__connect__result_template* precondition;
UD__connect__result_template* implied_template;
} implication_;
dynmatch_struct<UD__connect__result>* dyn_match;
};

void set_specific();
void copy_value(const UD__connect__result& other_value);
void copy_template(const UD__connect__result_template& other_value);

public:
UD__connect__result_template();
UD__connect__result_template(template_sel other_value);
UD__connect__result_template(const UD__connect__result& other_value);
UD__connect__result_template(const OPTIONAL<UD__connect__result>& other_value);
UD__connect__result_template(UD__connect__result_template* p_precondition, UD__connect__result_template* p_implied_template);
UD__connect__result_template(Dynamic_Match_Interface<UD__connect__result>* p_dyn_match);
UD__connect__result_template(const UD__connect__result_template& other_value);
~UD__connect__result_template();
UD__connect__result_template& operator=(template_sel other_value);
UD__connect__result_template& operator=(const UD__connect__result& other_value);
UD__connect__result_template& operator=(const OPTIONAL<UD__connect__result>& other_value);
UD__connect__result_template& operator=(const UD__connect__result_template& other_value);
boolean match(const UD__connect__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UD__connect__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UD__connect__result_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
UD__Result_template& result();
const UD__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const UD__connect__result& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class UD__send__data {
  OCTETSTRING field_data;
  INTEGER field_id;
public:
  UD__send__data();
  UD__send__data(const OCTETSTRING& par_data,
    const INTEGER& par_id);
  UD__send__data(const UD__send__data& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UD__send__data& operator=(const UD__send__data& other_value);
  boolean operator==(const UD__send__data& other_value) const;
  inline boolean operator!=(const UD__send__data& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OCTETSTRING& data()
    {return field_data;}
  inline const OCTETSTRING& data() const
    {return field_data;}
  inline INTEGER& id()
    {return field_id;}
  inline const INTEGER& id() const
    {return field_id;}
  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 UD__send__data_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UD__send__data_template *list_value;
} value_list;
struct {
UD__send__data_template* precondition;
UD__send__data_template* implied_template;
} implication_;
dynmatch_struct<UD__send__data>* dyn_match;
};

void set_specific();
void copy_value(const UD__send__data& other_value);
void copy_template(const UD__send__data_template& other_value);

public:
UD__send__data_template();
UD__send__data_template(template_sel other_value);
UD__send__data_template(const UD__send__data& other_value);
UD__send__data_template(const OPTIONAL<UD__send__data>& other_value);
UD__send__data_template(UD__send__data_template* p_precondition, UD__send__data_template* p_implied_template);
UD__send__data_template(Dynamic_Match_Interface<UD__send__data>* p_dyn_match);
UD__send__data_template(const UD__send__data_template& other_value);
~UD__send__data_template();
UD__send__data_template& operator=(template_sel other_value);
UD__send__data_template& operator=(const UD__send__data& other_value);
UD__send__data_template& operator=(const OPTIONAL<UD__send__data>& other_value);
UD__send__data_template& operator=(const UD__send__data_template& other_value);
boolean match(const UD__send__data& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UD__send__data valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UD__send__data_template& list_item(unsigned int list_index) const;
OCTETSTRING_template& data();
const OCTETSTRING_template& data() const;
INTEGER_template& id();
const INTEGER_template& id() const;
int size_of() const;
void log() const;
void log_match(const UD__send__data& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class UD__connected {
  CHARSTRING field_path;
  INTEGER field_id;
  OPTIONAL< UD__Result > field_result;
public:
  UD__connected();
  UD__connected(const CHARSTRING& par_path,
    const INTEGER& par_id,
    const OPTIONAL< UD__Result >& par_result);
  UD__connected(const UD__connected& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UD__connected& operator=(const UD__connected& other_value);
  boolean operator==(const UD__connected& other_value) const;
  inline boolean operator!=(const UD__connected& 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& path()
    {return field_path;}
  inline const CHARSTRING& path() const
    {return field_path;}
  inline INTEGER& id()
    {return field_id;}
  inline const INTEGER& id() const
    {return field_id;}
  inline OPTIONAL< UD__Result >& result()
    {return field_result;}
  inline const OPTIONAL< UD__Result >& result() const
    {return field_result;}
  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 UD__connected_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UD__connected_template *list_value;
} value_list;
struct {
UD__connected_template* precondition;
UD__connected_template* implied_template;
} implication_;
dynmatch_struct<UD__connected>* dyn_match;
};

void set_specific();
void copy_value(const UD__connected& other_value);
void copy_template(const UD__connected_template& other_value);

public:
UD__connected_template();
UD__connected_template(template_sel other_value);
UD__connected_template(const UD__connected& other_value);
UD__connected_template(const OPTIONAL<UD__connected>& other_value);
UD__connected_template(UD__connected_template* p_precondition, UD__connected_template* p_implied_template);
UD__connected_template(Dynamic_Match_Interface<UD__connected>* p_dyn_match);
UD__connected_template(const UD__connected_template& other_value);
~UD__connected_template();
UD__connected_template& operator=(template_sel other_value);
UD__connected_template& operator=(const UD__connected& other_value);
UD__connected_template& operator=(const OPTIONAL<UD__connected>& other_value);
UD__connected_template& operator=(const UD__connected_template& other_value);
boolean match(const UD__connected& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UD__connected valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UD__connected_template& list_item(unsigned int list_index) const;
CHARSTRING_template& path();
const CHARSTRING_template& path() const;
INTEGER_template& id();
const INTEGER_template& id() const;
UD__Result_template& result();
const UD__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const UD__connected& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class UD__listen {
  CHARSTRING field_path;
public:
  UD__listen();
  UD__listen(const CHARSTRING& par_path);
  UD__listen(const UD__listen& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UD__listen& operator=(const UD__listen& other_value);
  boolean operator==(const UD__listen& other_value) const;
  inline boolean operator!=(const UD__listen& 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& path()
    {return field_path;}
  inline const CHARSTRING& path() const
    {return field_path;}
  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 UD__listen_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UD__listen_template *list_value;
} value_list;
struct {
UD__listen_template* precondition;
UD__listen_template* implied_template;
} implication_;
dynmatch_struct<UD__listen>* dyn_match;
};

void set_specific();
void copy_value(const UD__listen& other_value);
void copy_template(const UD__listen_template& other_value);

public:
UD__listen_template();
UD__listen_template(template_sel other_value);
UD__listen_template(const UD__listen& other_value);
UD__listen_template(const OPTIONAL<UD__listen>& other_value);
UD__listen_template(UD__listen_template* p_precondition, UD__listen_template* p_implied_template);
UD__listen_template(Dynamic_Match_Interface<UD__listen>* p_dyn_match);
UD__listen_template(const UD__listen_template& other_value);
~UD__listen_template();
UD__listen_template& operator=(template_sel other_value);
UD__listen_template& operator=(const UD__listen& other_value);
UD__listen_template& operator=(const OPTIONAL<UD__listen>& other_value);
UD__listen_template& operator=(const UD__listen_template& other_value);
boolean match(const UD__listen& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UD__listen valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UD__listen_template& list_item(unsigned int list_index) const;
CHARSTRING_template& path();
const CHARSTRING_template& path() const;
int size_of() const;
void log() const;
void log_match(const UD__listen& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class UD__listen__result {
  INTEGER field_id;
  OPTIONAL< UD__Result > field_result;
public:
  UD__listen__result();
  UD__listen__result(const INTEGER& par_id,
    const OPTIONAL< UD__Result >& par_result);
  UD__listen__result(const UD__listen__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UD__listen__result& operator=(const UD__listen__result& other_value);
  boolean operator==(const UD__listen__result& other_value) const;
  inline boolean operator!=(const UD__listen__result& 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& id()
    {return field_id;}
  inline const INTEGER& id() const
    {return field_id;}
  inline OPTIONAL< UD__Result >& result()
    {return field_result;}
  inline const OPTIONAL< UD__Result >& result() const
    {return field_result;}
  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 UD__listen__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UD__listen__result_template *list_value;
} value_list;
struct {
UD__listen__result_template* precondition;
UD__listen__result_template* implied_template;
} implication_;
dynmatch_struct<UD__listen__result>* dyn_match;
};

void set_specific();
void copy_value(const UD__listen__result& other_value);
void copy_template(const UD__listen__result_template& other_value);

public:
UD__listen__result_template();
UD__listen__result_template(template_sel other_value);
UD__listen__result_template(const UD__listen__result& other_value);
UD__listen__result_template(const OPTIONAL<UD__listen__result>& other_value);
UD__listen__result_template(UD__listen__result_template* p_precondition, UD__listen__result_template* p_implied_template);
UD__listen__result_template(Dynamic_Match_Interface<UD__listen__result>* p_dyn_match);
UD__listen__result_template(const UD__listen__result_template& other_value);
~UD__listen__result_template();
UD__listen__result_template& operator=(template_sel other_value);
UD__listen__result_template& operator=(const UD__listen__result& other_value);
UD__listen__result_template& operator=(const OPTIONAL<UD__listen__result>& other_value);
UD__listen__result_template& operator=(const UD__listen__result_template& other_value);
boolean match(const UD__listen__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UD__listen__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UD__listen__result_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
UD__Result_template& result();
const UD__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const UD__listen__result& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class UD__shutdown {
  INTEGER field_id;
public:
  UD__shutdown();
  UD__shutdown(const INTEGER& par_id);
  UD__shutdown(const UD__shutdown& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  UD__shutdown& operator=(const UD__shutdown& other_value);
  boolean operator==(const UD__shutdown& other_value) const;
  inline boolean operator!=(const UD__shutdown& 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& id()
    {return field_id;}
  inline const INTEGER& id() const
    {return field_id;}
  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 UD__shutdown_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
UD__shutdown_template *list_value;
} value_list;
struct {
UD__shutdown_template* precondition;
UD__shutdown_template* implied_template;
} implication_;
dynmatch_struct<UD__shutdown>* dyn_match;
};

void set_specific();
void copy_value(const UD__shutdown& other_value);
void copy_template(const UD__shutdown_template& other_value);

public:
UD__shutdown_template();
UD__shutdown_template(template_sel other_value);
UD__shutdown_template(const UD__shutdown& other_value);
UD__shutdown_template(const OPTIONAL<UD__shutdown>& other_value);
UD__shutdown_template(UD__shutdown_template* p_precondition, UD__shutdown_template* p_implied_template);
UD__shutdown_template(Dynamic_Match_Interface<UD__shutdown>* p_dyn_match);
UD__shutdown_template(const UD__shutdown_template& other_value);
~UD__shutdown_template();
UD__shutdown_template& operator=(template_sel other_value);
UD__shutdown_template& operator=(const UD__shutdown& other_value);
UD__shutdown_template& operator=(const OPTIONAL<UD__shutdown>& other_value);
UD__shutdown_template& operator=(const UD__shutdown_template& other_value);
boolean match(const UD__shutdown& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
UD__shutdown valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
UD__shutdown_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
int size_of() const;
void log() const;
void log_match(const UD__shutdown& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};


/* Function prototypes */

extern void pre_init_module();
extern void post_init_module();

/* Global variable declarations */

extern const TTCN_Typedescriptor_t& ro__integer_descr_;
extern const TTCN_Typedescriptor_t& f__getMsgLen_descr_;
extern const TTCN_Typedescriptor_t& f__UD__getMsgLen_descr_;
extern const XERdescriptor_t PDU__UD_xer_;
extern const TTCN_OERdescriptor_t PDU__UD_oer_;
extern const TTCN_Typedescriptor_t PDU__UD_descr_;
extern const XERdescriptor_t Path_xer_;
extern const TTCN_Typedescriptor_t Path_descr_;
extern const TTCN_Typedescriptor_t UD__Result__code_descr_;
extern const TTCN_Typedescriptor_t UD__Result_descr_;
extern const XERdescriptor_t UD__Result_err_xer_;
extern const TTCN_Typedescriptor_t UD__Result_err_descr_;
extern const XERdescriptor_t UD__close_id_xer_;
extern const TTCN_Typedescriptor_t UD__close_id_descr_;
extern const TTCN_Typedescriptor_t UD__close_descr_;
extern const XERdescriptor_t UD__connect_path_xer_;
extern const TTCN_Typedescriptor_t UD__connect_path_descr_;
extern const XERdescriptor_t UD__connect_id_xer_;
extern const TTCN_Typedescriptor_t UD__connect_id_descr_;
extern const TTCN_Typedescriptor_t UD__connect_descr_;
extern const XERdescriptor_t UD__connect__result_id_xer_;
extern const TTCN_Typedescriptor_t UD__connect__result_id_descr_;
extern const TTCN_Typedescriptor_t UD__connect__result_descr_;
extern const XERdescriptor_t UD__send__data_data_xer_;
extern const TTCN_OERdescriptor_t UD__send__data_data_oer_;
extern const TTCN_Typedescriptor_t UD__send__data_data_descr_;
extern const XERdescriptor_t UD__send__data_id_xer_;
extern const TTCN_Typedescriptor_t UD__send__data_id_descr_;
extern const TTCN_Typedescriptor_t UD__send__data_descr_;
extern const XERdescriptor_t UD__connected_path_xer_;
extern const TTCN_Typedescriptor_t UD__connected_path_descr_;
extern const XERdescriptor_t UD__connected_id_xer_;
extern const TTCN_Typedescriptor_t UD__connected_id_descr_;
extern const TTCN_Typedescriptor_t UD__connected_descr_;
extern const XERdescriptor_t UD__listen_path_xer_;
extern const TTCN_Typedescriptor_t UD__listen_path_descr_;
extern const TTCN_Typedescriptor_t UD__listen_descr_;
extern const XERdescriptor_t UD__listen__result_id_xer_;
extern const TTCN_Typedescriptor_t UD__listen__result_id_descr_;
extern const TTCN_Typedescriptor_t UD__listen__result_descr_;
extern const XERdescriptor_t UD__shutdown_id_xer_;
extern const TTCN_Typedescriptor_t UD__shutdown_id_descr_;
extern const TTCN_Typedescriptor_t UD__shutdown_descr_;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
