demo/SocketCAN_Types.hh

// This C++ header file was generated by the TTCN-3 compiler
// of the TTCN-3 Test Executor version CRL 113 200/6 R6A
// for Lénárd Nagy (elnrnag@elx78355y6x) on Thu Oct 24 10:29:40 2019

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

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

#ifndef SocketCAN__Types_HH
#define SocketCAN__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 "Bcm.hh"
#include "Raw.hh"

#if TTCN3_VERSION != 60600
#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 SocketCAN__Types_HH
#endif

namespace SocketCAN__Types {

/* Forward declarations of classes */

class SocketCAN__timeval;
class SocketCAN__timeval_template;
class SocketCAN__CAN__or__CAN__FD__frame;
class SocketCAN__CAN__or__CAN__FD__frame_template;
class SocketCAN__ifr;
class SocketCAN__ifr_template;
class SocketCAN__if__any;
class SocketCAN__if__any_template;
class SocketCAN__send__data__ifu;
class SocketCAN__send__data__ifu_template;
class SocketCAN__ioctl__ifu;
class SocketCAN__ioctl__ifu_template;
class SocketCAN__Result__code;
class SocketCAN__Result__code_template;
class SocketCAN__Result;
class SocketCAN__Result_template;
class SocketCAN__socket;
class SocketCAN__socket_template;
class SocketCAN__socket__result;
class SocketCAN__socket__result_template;
class SocketCAN__ioctl;
class SocketCAN__ioctl_template;
class SocketCAN__ioctl__result;
class SocketCAN__ioctl__result_template;
class SocketCAN__connectu;
class SocketCAN__connectu_template;
class SocketCAN__connect__bcm;
class SocketCAN__connect__bcm_template;
class SocketCAN__connect;
class SocketCAN__connect_template;
class SocketCAN__connect__result;
class SocketCAN__connect__result_template;
class SocketCAN__bind__raw;
class SocketCAN__bind__raw_template;
class SocketCAN__bind__isotp;
class SocketCAN__bind__isotp_template;
class SocketCAN__bindu;
class SocketCAN__bindu_template;
class SocketCAN__bind;
class SocketCAN__bind_template;
class SocketCAN__bind__result;
class SocketCAN__bind__result_template;
class SocketCAN__send__data;
class SocketCAN__send__data_template;
class SocketCAN__send__data__result;
class SocketCAN__send__data__result_template;
class SocketCAN__write__data;
class SocketCAN__write__data_template;
class SocketCAN__write__data__result;
class SocketCAN__write__data__result_template;
class SocketCAN__write__isotp;
class SocketCAN__write__isotp_template;
class SocketCAN__write__isotp__result;
class SocketCAN__write__isotp__result_template;
class SocketCAN__receive__CAN__or__CAN__FD__frame;
class SocketCAN__receive__CAN__or__CAN__FD__frame_template;
class SocketCAN__receive__BCM__message;
class SocketCAN__receive__BCM__message_template;
class SocketCAN__receive__isotp__pdu;
class SocketCAN__receive__isotp__pdu_template;
class CAN__RAW__filters;
class CAN__RAW__filters_template;
class SocketCAN__setsockopt__commandu;
class SocketCAN__setsockopt__commandu_template;
class SocketCAN__setsockopt;
class SocketCAN__setsockopt_template;
class SocketCAN__setsockopt__result;
class SocketCAN__setsockopt__result_template;
class SocketCAN__close;
class SocketCAN__close_template;

} /* end of namespace */

#ifndef SocketCAN__Types_HH
#define SocketCAN__Types_HH

namespace SocketCAN__Types {

/* Type definitions */

typedef INTEGER SocketCAN__socketid;
typedef INTEGER_template SocketCAN__socketid_template;
typedef CHARSTRING SocketCAN__if__name;
typedef CHARSTRING_template SocketCAN__if__name_template;
typedef INTEGER SocketCAN__if__index;
typedef INTEGER_template SocketCAN__if__index_template;
typedef OCTETSTRING SocketCAN__Isotp__PDU;
typedef OCTETSTRING_template SocketCAN__Isotp__PDU_template;

/* Class definitions */

class SocketCAN__timeval {
  INTEGER field_tv__sec;
  INTEGER field_tv__usec;
public:
  SocketCAN__timeval();
  SocketCAN__timeval(const INTEGER& par_tv__sec,
    const INTEGER& par_tv__usec);
  SocketCAN__timeval(const SocketCAN__timeval& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__timeval& operator=(const SocketCAN__timeval& other_value);
  boolean operator==(const SocketCAN__timeval& other_value) const;
  inline boolean operator!=(const SocketCAN__timeval& 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& tv__sec()
    {return field_tv__sec;}
  inline const INTEGER& tv__sec() const
    {return field_tv__sec;}
  inline INTEGER& tv__usec()
    {return field_tv__usec;}
  inline const INTEGER& tv__usec() const
    {return field_tv__usec;}
  inline int size_of() const
    {return 2;}
  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 SocketCAN__timeval_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__timeval_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__timeval& other_value);
void copy_template(const SocketCAN__timeval_template& other_value);

public:
SocketCAN__timeval_template();
SocketCAN__timeval_template(template_sel other_value);
SocketCAN__timeval_template(const SocketCAN__timeval& other_value);
SocketCAN__timeval_template(const OPTIONAL<SocketCAN__timeval>& other_value);
SocketCAN__timeval_template(const SocketCAN__timeval_template& other_value);
~SocketCAN__timeval_template();
SocketCAN__timeval_template& operator=(template_sel other_value);
SocketCAN__timeval_template& operator=(const SocketCAN__timeval& other_value);
SocketCAN__timeval_template& operator=(const OPTIONAL<SocketCAN__timeval>& other_value);
SocketCAN__timeval_template& operator=(const SocketCAN__timeval_template& other_value);
boolean match(const SocketCAN__timeval& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__timeval valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__timeval_template& list_item(unsigned int list_index) const;
INTEGER_template& tv__sec();
const INTEGER_template& tv__sec() const;
INTEGER_template& tv__usec();
const INTEGER_template& tv__usec() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__timeval& 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 SocketCAN__CAN__or__CAN__FD__frame : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_can__frame = 1, ALT_canfd__frame = 2 };
private:
union_selection_type union_selection;
union {
Can::CAN__frame *field_can__frame;
Can::CANFD__frame *field_canfd__frame;
};
void copy_value(const SocketCAN__CAN__or__CAN__FD__frame& other_value);

public:
SocketCAN__CAN__or__CAN__FD__frame();
SocketCAN__CAN__or__CAN__FD__frame(const SocketCAN__CAN__or__CAN__FD__frame& other_value);
~SocketCAN__CAN__or__CAN__FD__frame();
SocketCAN__CAN__or__CAN__FD__frame& operator=(const SocketCAN__CAN__or__CAN__FD__frame& other_value);
boolean operator==(const SocketCAN__CAN__or__CAN__FD__frame& other_value) const;
inline boolean operator!=(const SocketCAN__CAN__or__CAN__FD__frame& other_value) const { return !(*this == other_value); }
Can::CAN__frame& can__frame();
const Can::CAN__frame& can__frame() const;
Can::CANFD__frame& canfd__frame();
const Can::CANFD__frame& canfd__frame() 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 SocketCAN__CAN__or__CAN__FD__frame_template : public Base_Template {
union {
struct {
SocketCAN__CAN__or__CAN__FD__frame::union_selection_type union_selection;
union {
Can::CAN__frame_template *field_can__frame;
Can::CANFD__frame_template *field_canfd__frame;
};
} single_value;
struct {
unsigned int n_values;
SocketCAN__CAN__or__CAN__FD__frame_template *list_value;
} value_list;
};
void copy_value(const SocketCAN__CAN__or__CAN__FD__frame& other_value);

void copy_template(const SocketCAN__CAN__or__CAN__FD__frame_template& other_value);

public:
SocketCAN__CAN__or__CAN__FD__frame_template();
SocketCAN__CAN__or__CAN__FD__frame_template(template_sel other_value);
SocketCAN__CAN__or__CAN__FD__frame_template(const SocketCAN__CAN__or__CAN__FD__frame& other_value);
SocketCAN__CAN__or__CAN__FD__frame_template(const OPTIONAL<SocketCAN__CAN__or__CAN__FD__frame>& other_value);
SocketCAN__CAN__or__CAN__FD__frame_template(const SocketCAN__CAN__or__CAN__FD__frame_template& other_value);
~SocketCAN__CAN__or__CAN__FD__frame_template();
void clean_up();
SocketCAN__CAN__or__CAN__FD__frame_template& operator=(template_sel other_value);
SocketCAN__CAN__or__CAN__FD__frame_template& operator=(const SocketCAN__CAN__or__CAN__FD__frame& other_value);
SocketCAN__CAN__or__CAN__FD__frame_template& operator=(const OPTIONAL<SocketCAN__CAN__or__CAN__FD__frame>& other_value);
SocketCAN__CAN__or__CAN__FD__frame_template& operator=(const SocketCAN__CAN__or__CAN__FD__frame_template& other_value);
boolean match(const SocketCAN__CAN__or__CAN__FD__frame& other_value, boolean legacy = FALSE) const;
boolean is_value() const;SocketCAN__CAN__or__CAN__FD__frame valueof() const;
SocketCAN__CAN__or__CAN__FD__frame_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
Can::CAN__frame_template& can__frame();
const Can::CAN__frame_template& can__frame() const;
Can::CANFD__frame_template& canfd__frame();
const Can::CANFD__frame_template& canfd__frame() const;
boolean ischosen(SocketCAN__CAN__or__CAN__FD__frame::union_selection_type checked_selection) const;
void log() const;
void log_match(const SocketCAN__CAN__or__CAN__FD__frame& 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 SocketCAN__ifr {
  OPTIONAL<CHARSTRING> field_if__name;
  OPTIONAL<INTEGER> field_if__index;
public:
  SocketCAN__ifr();
  SocketCAN__ifr(const OPTIONAL<CHARSTRING>& par_if__name,
    const OPTIONAL<INTEGER>& par_if__index);
  SocketCAN__ifr(const SocketCAN__ifr& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__ifr& operator=(const SocketCAN__ifr& other_value);
  boolean operator==(const SocketCAN__ifr& other_value) const;
  inline boolean operator!=(const SocketCAN__ifr& 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<CHARSTRING>& if__name()
    {return field_if__name;}
  inline const OPTIONAL<CHARSTRING>& if__name() const
    {return field_if__name;}
  inline OPTIONAL<INTEGER>& if__index()
    {return field_if__index;}
  inline const OPTIONAL<INTEGER>& if__index() const
    {return field_if__index;}
  int size_of() const;
  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 SocketCAN__ifr_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__ifr_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__ifr& other_value);
void copy_template(const SocketCAN__ifr_template& other_value);

public:
SocketCAN__ifr_template();
SocketCAN__ifr_template(template_sel other_value);
SocketCAN__ifr_template(const SocketCAN__ifr& other_value);
SocketCAN__ifr_template(const OPTIONAL<SocketCAN__ifr>& other_value);
SocketCAN__ifr_template(const SocketCAN__ifr_template& other_value);
~SocketCAN__ifr_template();
SocketCAN__ifr_template& operator=(template_sel other_value);
SocketCAN__ifr_template& operator=(const SocketCAN__ifr& other_value);
SocketCAN__ifr_template& operator=(const OPTIONAL<SocketCAN__ifr>& other_value);
SocketCAN__ifr_template& operator=(const SocketCAN__ifr_template& other_value);
boolean match(const SocketCAN__ifr& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__ifr valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__ifr_template& list_item(unsigned int list_index) const;
CHARSTRING_template& if__name();
const CHARSTRING_template& if__name() const;
INTEGER_template& if__index();
const INTEGER_template& if__index() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__ifr& 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 SocketCAN__if__any : public Base_Type { // enum
friend class SocketCAN__if__any_template;
public:
enum enum_type { ANY__INTERFACE = 0, UNKNOWN_VALUE = 1, UNBOUND_VALUE = 2 };
private:
enum_type enum_value;

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

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

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

void copy_template(const SocketCAN__if__any_template& other_value);

public:
SocketCAN__if__any_template();
SocketCAN__if__any_template(template_sel other_value);
SocketCAN__if__any_template(int other_value);
SocketCAN__if__any_template(SocketCAN__if__any::enum_type other_value);
SocketCAN__if__any_template(const SocketCAN__if__any& other_value);
SocketCAN__if__any_template(const OPTIONAL<SocketCAN__if__any>& other_value);
SocketCAN__if__any_template(const SocketCAN__if__any_template& other_value);
~SocketCAN__if__any_template();

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

boolean match(SocketCAN__if__any::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const SocketCAN__if__any& other_value, boolean legacy = FALSE) const;
SocketCAN__if__any::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__if__any_template& list_item(unsigned int list_index);
void log() const;
void log_match(const SocketCAN__if__any& 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 SocketCAN__send__data__ifu : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_if__name = 1, ALT_if__index = 2, ALT_if__any = 3 };
private:
union_selection_type union_selection;
union {
CHARSTRING *field_if__name;
INTEGER *field_if__index;
SocketCAN__if__any *field_if__any;
};
void copy_value(const SocketCAN__send__data__ifu& other_value);

public:
SocketCAN__send__data__ifu();
SocketCAN__send__data__ifu(const SocketCAN__send__data__ifu& other_value);
~SocketCAN__send__data__ifu();
SocketCAN__send__data__ifu& operator=(const SocketCAN__send__data__ifu& other_value);
boolean operator==(const SocketCAN__send__data__ifu& other_value) const;
inline boolean operator!=(const SocketCAN__send__data__ifu& other_value) const { return !(*this == other_value); }
CHARSTRING& if__name();
const CHARSTRING& if__name() const;
INTEGER& if__index();
const INTEGER& if__index() const;
SocketCAN__if__any& if__any();
const SocketCAN__if__any& if__any() 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 SocketCAN__send__data__ifu_template : public Base_Template {
union {
struct {
SocketCAN__send__data__ifu::union_selection_type union_selection;
union {
CHARSTRING_template *field_if__name;
INTEGER_template *field_if__index;
SocketCAN__if__any_template *field_if__any;
};
} single_value;
struct {
unsigned int n_values;
SocketCAN__send__data__ifu_template *list_value;
} value_list;
};
void copy_value(const SocketCAN__send__data__ifu& other_value);

void copy_template(const SocketCAN__send__data__ifu_template& other_value);

public:
SocketCAN__send__data__ifu_template();
SocketCAN__send__data__ifu_template(template_sel other_value);
SocketCAN__send__data__ifu_template(const SocketCAN__send__data__ifu& other_value);
SocketCAN__send__data__ifu_template(const OPTIONAL<SocketCAN__send__data__ifu>& other_value);
SocketCAN__send__data__ifu_template(const SocketCAN__send__data__ifu_template& other_value);
~SocketCAN__send__data__ifu_template();
void clean_up();
SocketCAN__send__data__ifu_template& operator=(template_sel other_value);
SocketCAN__send__data__ifu_template& operator=(const SocketCAN__send__data__ifu& other_value);
SocketCAN__send__data__ifu_template& operator=(const OPTIONAL<SocketCAN__send__data__ifu>& other_value);
SocketCAN__send__data__ifu_template& operator=(const SocketCAN__send__data__ifu_template& other_value);
boolean match(const SocketCAN__send__data__ifu& other_value, boolean legacy = FALSE) const;
boolean is_value() const;SocketCAN__send__data__ifu valueof() const;
SocketCAN__send__data__ifu_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
CHARSTRING_template& if__name();
const CHARSTRING_template& if__name() const;
INTEGER_template& if__index();
const INTEGER_template& if__index() const;
SocketCAN__if__any_template& if__any();
const SocketCAN__if__any_template& if__any() const;
boolean ischosen(SocketCAN__send__data__ifu::union_selection_type checked_selection) const;
void log() const;
void log_match(const SocketCAN__send__data__ifu& 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 SocketCAN__ioctl__ifu : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_if__name = 1, ALT_if__index = 2, ALT_if__any = 3 };
private:
union_selection_type union_selection;
union {
CHARSTRING *field_if__name;
INTEGER *field_if__index;
SocketCAN__if__any *field_if__any;
};
void copy_value(const SocketCAN__ioctl__ifu& other_value);

public:
SocketCAN__ioctl__ifu();
SocketCAN__ioctl__ifu(const SocketCAN__ioctl__ifu& other_value);
~SocketCAN__ioctl__ifu();
SocketCAN__ioctl__ifu& operator=(const SocketCAN__ioctl__ifu& other_value);
boolean operator==(const SocketCAN__ioctl__ifu& other_value) const;
inline boolean operator!=(const SocketCAN__ioctl__ifu& other_value) const { return !(*this == other_value); }
CHARSTRING& if__name();
const CHARSTRING& if__name() const;
INTEGER& if__index();
const INTEGER& if__index() const;
SocketCAN__if__any& if__any();
const SocketCAN__if__any& if__any() 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 SocketCAN__ioctl__ifu_template : public Base_Template {
union {
struct {
SocketCAN__ioctl__ifu::union_selection_type union_selection;
union {
CHARSTRING_template *field_if__name;
INTEGER_template *field_if__index;
SocketCAN__if__any_template *field_if__any;
};
} single_value;
struct {
unsigned int n_values;
SocketCAN__ioctl__ifu_template *list_value;
} value_list;
};
void copy_value(const SocketCAN__ioctl__ifu& other_value);

void copy_template(const SocketCAN__ioctl__ifu_template& other_value);

public:
SocketCAN__ioctl__ifu_template();
SocketCAN__ioctl__ifu_template(template_sel other_value);
SocketCAN__ioctl__ifu_template(const SocketCAN__ioctl__ifu& other_value);
SocketCAN__ioctl__ifu_template(const OPTIONAL<SocketCAN__ioctl__ifu>& other_value);
SocketCAN__ioctl__ifu_template(const SocketCAN__ioctl__ifu_template& other_value);
~SocketCAN__ioctl__ifu_template();
void clean_up();
SocketCAN__ioctl__ifu_template& operator=(template_sel other_value);
SocketCAN__ioctl__ifu_template& operator=(const SocketCAN__ioctl__ifu& other_value);
SocketCAN__ioctl__ifu_template& operator=(const OPTIONAL<SocketCAN__ioctl__ifu>& other_value);
SocketCAN__ioctl__ifu_template& operator=(const SocketCAN__ioctl__ifu_template& other_value);
boolean match(const SocketCAN__ioctl__ifu& other_value, boolean legacy = FALSE) const;
boolean is_value() const;SocketCAN__ioctl__ifu valueof() const;
SocketCAN__ioctl__ifu_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
CHARSTRING_template& if__name();
const CHARSTRING_template& if__name() const;
INTEGER_template& if__index();
const INTEGER_template& if__index() const;
SocketCAN__if__any_template& if__any();
const SocketCAN__if__any_template& if__any() const;
boolean ischosen(SocketCAN__ioctl__ifu::union_selection_type checked_selection) const;
void log() const;
void log_match(const SocketCAN__ioctl__ifu& 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 SocketCAN__Result__code : public Base_Type { // enum
friend class SocketCAN__Result__code_template;
public:
enum enum_type { SocketCAN__ERROR = 0, SocketCAN__SUCCESS = 1, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

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

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

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

static int enum2int(enum_type enum_par);
static int enum2int(const SocketCAN__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 SocketCAN__Result__code_template : public Base_Template {
union {
SocketCAN__Result__code::enum_type single_value;
struct {
unsigned int n_values;
SocketCAN__Result__code_template *list_value;
} value_list;
};

void copy_template(const SocketCAN__Result__code_template& other_value);

public:
SocketCAN__Result__code_template();
SocketCAN__Result__code_template(template_sel other_value);
SocketCAN__Result__code_template(int other_value);
SocketCAN__Result__code_template(SocketCAN__Result__code::enum_type other_value);
SocketCAN__Result__code_template(const SocketCAN__Result__code& other_value);
SocketCAN__Result__code_template(const OPTIONAL<SocketCAN__Result__code>& other_value);
SocketCAN__Result__code_template(const SocketCAN__Result__code_template& other_value);
~SocketCAN__Result__code_template();

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

boolean match(SocketCAN__Result__code::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const SocketCAN__Result__code& other_value, boolean legacy = FALSE) const;
SocketCAN__Result__code::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__Result__code_template& list_item(unsigned int list_index);
void log() const;
void log_match(const SocketCAN__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 SocketCAN__Result {
  SocketCAN__Result__code field_result__code;
  OPTIONAL<INTEGER> field_err;
  OPTIONAL<CHARSTRING> field_err__text;
public:
  SocketCAN__Result();
  SocketCAN__Result(const SocketCAN__Result__code& par_result__code,
    const OPTIONAL<INTEGER>& par_err,
    const OPTIONAL<CHARSTRING>& par_err__text);
  SocketCAN__Result(const SocketCAN__Result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__Result& operator=(const SocketCAN__Result& other_value);
  boolean operator==(const SocketCAN__Result& other_value) const;
  inline boolean operator!=(const SocketCAN__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 SocketCAN__Result__code& result__code()
    {return field_result__code;}
  inline const SocketCAN__Result__code& result__code() const
    {return field_result__code;}
  inline OPTIONAL<INTEGER>& err()
    {return field_err;}
  inline const OPTIONAL<INTEGER>& err() const
    {return field_err;}
  inline OPTIONAL<CHARSTRING>& err__text()
    {return field_err__text;}
  inline const OPTIONAL<CHARSTRING>& err__text() const
    {return field_err__text;}
  int size_of() const;
  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 SocketCAN__Result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__Result_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__Result& other_value);
void copy_template(const SocketCAN__Result_template& other_value);

public:
SocketCAN__Result_template();
SocketCAN__Result_template(template_sel other_value);
SocketCAN__Result_template(const SocketCAN__Result& other_value);
SocketCAN__Result_template(const OPTIONAL<SocketCAN__Result>& other_value);
SocketCAN__Result_template(const SocketCAN__Result_template& other_value);
~SocketCAN__Result_template();
SocketCAN__Result_template& operator=(template_sel other_value);
SocketCAN__Result_template& operator=(const SocketCAN__Result& other_value);
SocketCAN__Result_template& operator=(const OPTIONAL<SocketCAN__Result>& other_value);
SocketCAN__Result_template& operator=(const SocketCAN__Result_template& other_value);
boolean match(const SocketCAN__Result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__Result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__Result_template& list_item(unsigned int list_index) const;
SocketCAN__Result__code_template& result__code();
const SocketCAN__Result__code_template& result__code() const;
INTEGER_template& err();
const INTEGER_template& err() const;
CHARSTRING_template& err__text();
const CHARSTRING_template& err__text() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__Result& 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 SocketCAN__socket {
  Can::AdresseFamily__enum field_domain;
  Can::ProtocolFamily__enum field_ptype;
  Can::PF__CAN__protocols__enum field_protocol;
public:
  SocketCAN__socket();
  SocketCAN__socket(const Can::AdresseFamily__enum& par_domain,
    const Can::ProtocolFamily__enum& par_ptype,
    const Can::PF__CAN__protocols__enum& par_protocol);
  SocketCAN__socket(const SocketCAN__socket& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__socket& operator=(const SocketCAN__socket& other_value);
  boolean operator==(const SocketCAN__socket& other_value) const;
  inline boolean operator!=(const SocketCAN__socket& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline Can::AdresseFamily__enum& domain()
    {return field_domain;}
  inline const Can::AdresseFamily__enum& domain() const
    {return field_domain;}
  inline Can::ProtocolFamily__enum& ptype()
    {return field_ptype;}
  inline const Can::ProtocolFamily__enum& ptype() const
    {return field_ptype;}
  inline Can::PF__CAN__protocols__enum& protocol()
    {return field_protocol;}
  inline const Can::PF__CAN__protocols__enum& protocol() const
    {return field_protocol;}
  inline int size_of() const
    {return 3;}
  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 SocketCAN__socket_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__socket_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__socket& other_value);
void copy_template(const SocketCAN__socket_template& other_value);

public:
SocketCAN__socket_template();
SocketCAN__socket_template(template_sel other_value);
SocketCAN__socket_template(const SocketCAN__socket& other_value);
SocketCAN__socket_template(const OPTIONAL<SocketCAN__socket>& other_value);
SocketCAN__socket_template(const SocketCAN__socket_template& other_value);
~SocketCAN__socket_template();
SocketCAN__socket_template& operator=(template_sel other_value);
SocketCAN__socket_template& operator=(const SocketCAN__socket& other_value);
SocketCAN__socket_template& operator=(const OPTIONAL<SocketCAN__socket>& other_value);
SocketCAN__socket_template& operator=(const SocketCAN__socket_template& other_value);
boolean match(const SocketCAN__socket& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__socket valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__socket_template& list_item(unsigned int list_index) const;
Can::AdresseFamily__enum_template& domain();
const Can::AdresseFamily__enum_template& domain() const;
Can::ProtocolFamily__enum_template& ptype();
const Can::ProtocolFamily__enum_template& ptype() const;
Can::PF__CAN__protocols__enum_template& protocol();
const Can::PF__CAN__protocols__enum_template& protocol() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__socket& 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 SocketCAN__socket__result {
  INTEGER field_id;
  SocketCAN__Result field_result;
public:
  SocketCAN__socket__result();
  SocketCAN__socket__result(const INTEGER& par_id,
    const SocketCAN__Result& par_result);
  SocketCAN__socket__result(const SocketCAN__socket__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__socket__result& operator=(const SocketCAN__socket__result& other_value);
  boolean operator==(const SocketCAN__socket__result& other_value) const;
  inline boolean operator!=(const SocketCAN__socket__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 SocketCAN__Result& result()
    {return field_result;}
  inline const SocketCAN__Result& result() const
    {return field_result;}
  inline int size_of() const
    {return 2;}
  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 SocketCAN__socket__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__socket__result_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__socket__result& other_value);
void copy_template(const SocketCAN__socket__result_template& other_value);

public:
SocketCAN__socket__result_template();
SocketCAN__socket__result_template(template_sel other_value);
SocketCAN__socket__result_template(const SocketCAN__socket__result& other_value);
SocketCAN__socket__result_template(const OPTIONAL<SocketCAN__socket__result>& other_value);
SocketCAN__socket__result_template(const SocketCAN__socket__result_template& other_value);
~SocketCAN__socket__result_template();
SocketCAN__socket__result_template& operator=(template_sel other_value);
SocketCAN__socket__result_template& operator=(const SocketCAN__socket__result& other_value);
SocketCAN__socket__result_template& operator=(const OPTIONAL<SocketCAN__socket__result>& other_value);
SocketCAN__socket__result_template& operator=(const SocketCAN__socket__result_template& other_value);
boolean match(const SocketCAN__socket__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__socket__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__socket__result_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
SocketCAN__Result_template& result();
const SocketCAN__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__socket__result& 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 SocketCAN__ioctl {
  INTEGER field_id;
  OPTIONAL<SocketCAN__ioctl__ifu> field_ifu;
public:
  SocketCAN__ioctl();
  SocketCAN__ioctl(const INTEGER& par_id,
    const OPTIONAL<SocketCAN__ioctl__ifu>& par_ifu);
  SocketCAN__ioctl(const SocketCAN__ioctl& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__ioctl& operator=(const SocketCAN__ioctl& other_value);
  boolean operator==(const SocketCAN__ioctl& other_value) const;
  inline boolean operator!=(const SocketCAN__ioctl& 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<SocketCAN__ioctl__ifu>& ifu()
    {return field_ifu;}
  inline const OPTIONAL<SocketCAN__ioctl__ifu>& ifu() const
    {return field_ifu;}
  int size_of() const;
  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 SocketCAN__ioctl_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__ioctl_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__ioctl& other_value);
void copy_template(const SocketCAN__ioctl_template& other_value);

public:
SocketCAN__ioctl_template();
SocketCAN__ioctl_template(template_sel other_value);
SocketCAN__ioctl_template(const SocketCAN__ioctl& other_value);
SocketCAN__ioctl_template(const OPTIONAL<SocketCAN__ioctl>& other_value);
SocketCAN__ioctl_template(const SocketCAN__ioctl_template& other_value);
~SocketCAN__ioctl_template();
SocketCAN__ioctl_template& operator=(template_sel other_value);
SocketCAN__ioctl_template& operator=(const SocketCAN__ioctl& other_value);
SocketCAN__ioctl_template& operator=(const OPTIONAL<SocketCAN__ioctl>& other_value);
SocketCAN__ioctl_template& operator=(const SocketCAN__ioctl_template& other_value);
boolean match(const SocketCAN__ioctl& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__ioctl valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__ioctl_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
SocketCAN__ioctl__ifu_template& ifu();
const SocketCAN__ioctl__ifu_template& ifu() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__ioctl& 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 SocketCAN__ioctl__result {
  SocketCAN__ifr field_ifr;
  SocketCAN__Result field_result;
public:
  SocketCAN__ioctl__result();
  SocketCAN__ioctl__result(const SocketCAN__ifr& par_ifr,
    const SocketCAN__Result& par_result);
  SocketCAN__ioctl__result(const SocketCAN__ioctl__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__ioctl__result& operator=(const SocketCAN__ioctl__result& other_value);
  boolean operator==(const SocketCAN__ioctl__result& other_value) const;
  inline boolean operator!=(const SocketCAN__ioctl__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 SocketCAN__ifr& ifr()
    {return field_ifr;}
  inline const SocketCAN__ifr& ifr() const
    {return field_ifr;}
  inline SocketCAN__Result& result()
    {return field_result;}
  inline const SocketCAN__Result& result() const
    {return field_result;}
  inline int size_of() const
    {return 2;}
  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 SocketCAN__ioctl__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__ioctl__result_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__ioctl__result& other_value);
void copy_template(const SocketCAN__ioctl__result_template& other_value);

public:
SocketCAN__ioctl__result_template();
SocketCAN__ioctl__result_template(template_sel other_value);
SocketCAN__ioctl__result_template(const SocketCAN__ioctl__result& other_value);
SocketCAN__ioctl__result_template(const OPTIONAL<SocketCAN__ioctl__result>& other_value);
SocketCAN__ioctl__result_template(const SocketCAN__ioctl__result_template& other_value);
~SocketCAN__ioctl__result_template();
SocketCAN__ioctl__result_template& operator=(template_sel other_value);
SocketCAN__ioctl__result_template& operator=(const SocketCAN__ioctl__result& other_value);
SocketCAN__ioctl__result_template& operator=(const OPTIONAL<SocketCAN__ioctl__result>& other_value);
SocketCAN__ioctl__result_template& operator=(const SocketCAN__ioctl__result_template& other_value);
boolean match(const SocketCAN__ioctl__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__ioctl__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__ioctl__result_template& list_item(unsigned int list_index) const;
SocketCAN__ifr_template& ifr();
const SocketCAN__ifr_template& ifr() const;
SocketCAN__Result_template& result();
const SocketCAN__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__ioctl__result& 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 SocketCAN__connectu : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_bcm = 1 };
private:
union_selection_type union_selection;
union {
SocketCAN__connect__bcm *field_bcm;
};
void copy_value(const SocketCAN__connectu& other_value);

public:
SocketCAN__connectu();
SocketCAN__connectu(const SocketCAN__connectu& other_value);
~SocketCAN__connectu();
SocketCAN__connectu& operator=(const SocketCAN__connectu& other_value);
boolean operator==(const SocketCAN__connectu& other_value) const;
inline boolean operator!=(const SocketCAN__connectu& other_value) const { return !(*this == other_value); }
SocketCAN__connect__bcm& bcm();
const SocketCAN__connect__bcm& bcm() 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 SocketCAN__connectu_template : public Base_Template {
union {
struct {
SocketCAN__connectu::union_selection_type union_selection;
union {
SocketCAN__connect__bcm_template *field_bcm;
};
} single_value;
struct {
unsigned int n_values;
SocketCAN__connectu_template *list_value;
} value_list;
};
void copy_value(const SocketCAN__connectu& other_value);

void copy_template(const SocketCAN__connectu_template& other_value);

public:
SocketCAN__connectu_template();
SocketCAN__connectu_template(template_sel other_value);
SocketCAN__connectu_template(const SocketCAN__connectu& other_value);
SocketCAN__connectu_template(const OPTIONAL<SocketCAN__connectu>& other_value);
SocketCAN__connectu_template(const SocketCAN__connectu_template& other_value);
~SocketCAN__connectu_template();
void clean_up();
SocketCAN__connectu_template& operator=(template_sel other_value);
SocketCAN__connectu_template& operator=(const SocketCAN__connectu& other_value);
SocketCAN__connectu_template& operator=(const OPTIONAL<SocketCAN__connectu>& other_value);
SocketCAN__connectu_template& operator=(const SocketCAN__connectu_template& other_value);
boolean match(const SocketCAN__connectu& other_value, boolean legacy = FALSE) const;
boolean is_value() const;SocketCAN__connectu valueof() const;
SocketCAN__connectu_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__connect__bcm_template& bcm();
const SocketCAN__connect__bcm_template& bcm() const;
boolean ischosen(SocketCAN__connectu::union_selection_type checked_selection) const;
void log() const;
void log_match(const SocketCAN__connectu& 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 SocketCAN__connect__bcm {
  INTEGER field_if__index;
public:
  SocketCAN__connect__bcm();
  SocketCAN__connect__bcm(const INTEGER& par_if__index);
  SocketCAN__connect__bcm(const SocketCAN__connect__bcm& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__connect__bcm& operator=(const SocketCAN__connect__bcm& other_value);
  boolean operator==(const SocketCAN__connect__bcm& other_value) const;
  inline boolean operator!=(const SocketCAN__connect__bcm& 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& if__index()
    {return field_if__index;}
  inline const INTEGER& if__index() const
    {return field_if__index;}
  inline int size_of() const
    {return 1;}
  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 SocketCAN__connect__bcm_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__connect__bcm_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__connect__bcm& other_value);
void copy_template(const SocketCAN__connect__bcm_template& other_value);

public:
SocketCAN__connect__bcm_template();
SocketCAN__connect__bcm_template(template_sel other_value);
SocketCAN__connect__bcm_template(const SocketCAN__connect__bcm& other_value);
SocketCAN__connect__bcm_template(const OPTIONAL<SocketCAN__connect__bcm>& other_value);
SocketCAN__connect__bcm_template(const SocketCAN__connect__bcm_template& other_value);
~SocketCAN__connect__bcm_template();
SocketCAN__connect__bcm_template& operator=(template_sel other_value);
SocketCAN__connect__bcm_template& operator=(const SocketCAN__connect__bcm& other_value);
SocketCAN__connect__bcm_template& operator=(const OPTIONAL<SocketCAN__connect__bcm>& other_value);
SocketCAN__connect__bcm_template& operator=(const SocketCAN__connect__bcm_template& other_value);
boolean match(const SocketCAN__connect__bcm& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__connect__bcm valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__connect__bcm_template& list_item(unsigned int list_index) const;
INTEGER_template& if__index();
const INTEGER_template& if__index() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__connect__bcm& 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 SocketCAN__connect {
  INTEGER field_id;
  SocketCAN__connectu field_connectu;
public:
  SocketCAN__connect();
  SocketCAN__connect(const INTEGER& par_id,
    const SocketCAN__connectu& par_connectu);
  SocketCAN__connect(const SocketCAN__connect& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__connect& operator=(const SocketCAN__connect& other_value);
  boolean operator==(const SocketCAN__connect& other_value) const;
  inline boolean operator!=(const SocketCAN__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 INTEGER& id()
    {return field_id;}
  inline const INTEGER& id() const
    {return field_id;}
  inline SocketCAN__connectu& connectu()
    {return field_connectu;}
  inline const SocketCAN__connectu& connectu() const
    {return field_connectu;}
  inline int size_of() const
    {return 2;}
  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 SocketCAN__connect_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__connect_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__connect& other_value);
void copy_template(const SocketCAN__connect_template& other_value);

public:
SocketCAN__connect_template();
SocketCAN__connect_template(template_sel other_value);
SocketCAN__connect_template(const SocketCAN__connect& other_value);
SocketCAN__connect_template(const OPTIONAL<SocketCAN__connect>& other_value);
SocketCAN__connect_template(const SocketCAN__connect_template& other_value);
~SocketCAN__connect_template();
SocketCAN__connect_template& operator=(template_sel other_value);
SocketCAN__connect_template& operator=(const SocketCAN__connect& other_value);
SocketCAN__connect_template& operator=(const OPTIONAL<SocketCAN__connect>& other_value);
SocketCAN__connect_template& operator=(const SocketCAN__connect_template& other_value);
boolean match(const SocketCAN__connect& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__connect valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__connect_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
SocketCAN__connectu_template& connectu();
const SocketCAN__connectu_template& connectu() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__connect& 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 SocketCAN__connect__result {
  SocketCAN__Result field_result;
public:
  SocketCAN__connect__result();
  SocketCAN__connect__result(const SocketCAN__Result& par_result);
  SocketCAN__connect__result(const SocketCAN__connect__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__connect__result& operator=(const SocketCAN__connect__result& other_value);
  boolean operator==(const SocketCAN__connect__result& other_value) const;
  inline boolean operator!=(const SocketCAN__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 SocketCAN__Result& result()
    {return field_result;}
  inline const SocketCAN__Result& result() const
    {return field_result;}
  inline int size_of() const
    {return 1;}
  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 SocketCAN__connect__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__connect__result_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__connect__result& other_value);
void copy_template(const SocketCAN__connect__result_template& other_value);

public:
SocketCAN__connect__result_template();
SocketCAN__connect__result_template(template_sel other_value);
SocketCAN__connect__result_template(const SocketCAN__connect__result& other_value);
SocketCAN__connect__result_template(const OPTIONAL<SocketCAN__connect__result>& other_value);
SocketCAN__connect__result_template(const SocketCAN__connect__result_template& other_value);
~SocketCAN__connect__result_template();
SocketCAN__connect__result_template& operator=(template_sel other_value);
SocketCAN__connect__result_template& operator=(const SocketCAN__connect__result& other_value);
SocketCAN__connect__result_template& operator=(const OPTIONAL<SocketCAN__connect__result>& other_value);
SocketCAN__connect__result_template& operator=(const SocketCAN__connect__result_template& other_value);
boolean match(const SocketCAN__connect__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__connect__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__connect__result_template& list_item(unsigned int list_index) const;
SocketCAN__Result_template& result();
const SocketCAN__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__connect__result& 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 SocketCAN__bind__raw {
  INTEGER field_if__index;
public:
  SocketCAN__bind__raw();
  SocketCAN__bind__raw(const INTEGER& par_if__index);
  SocketCAN__bind__raw(const SocketCAN__bind__raw& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__bind__raw& operator=(const SocketCAN__bind__raw& other_value);
  boolean operator==(const SocketCAN__bind__raw& other_value) const;
  inline boolean operator!=(const SocketCAN__bind__raw& 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& if__index()
    {return field_if__index;}
  inline const INTEGER& if__index() const
    {return field_if__index;}
  inline int size_of() const
    {return 1;}
  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 SocketCAN__bind__raw_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__bind__raw_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__bind__raw& other_value);
void copy_template(const SocketCAN__bind__raw_template& other_value);

public:
SocketCAN__bind__raw_template();
SocketCAN__bind__raw_template(template_sel other_value);
SocketCAN__bind__raw_template(const SocketCAN__bind__raw& other_value);
SocketCAN__bind__raw_template(const OPTIONAL<SocketCAN__bind__raw>& other_value);
SocketCAN__bind__raw_template(const SocketCAN__bind__raw_template& other_value);
~SocketCAN__bind__raw_template();
SocketCAN__bind__raw_template& operator=(template_sel other_value);
SocketCAN__bind__raw_template& operator=(const SocketCAN__bind__raw& other_value);
SocketCAN__bind__raw_template& operator=(const OPTIONAL<SocketCAN__bind__raw>& other_value);
SocketCAN__bind__raw_template& operator=(const SocketCAN__bind__raw_template& other_value);
boolean match(const SocketCAN__bind__raw& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__bind__raw valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__bind__raw_template& list_item(unsigned int list_index) const;
INTEGER_template& if__index();
const INTEGER_template& if__index() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__bind__raw& 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 SocketCAN__bind__isotp {
  INTEGER field_if__index;
  OCTETSTRING field_rx__can__id;
  OCTETSTRING field_tx__can__id;
public:
  SocketCAN__bind__isotp();
  SocketCAN__bind__isotp(const INTEGER& par_if__index,
    const OCTETSTRING& par_rx__can__id,
    const OCTETSTRING& par_tx__can__id);
  SocketCAN__bind__isotp(const SocketCAN__bind__isotp& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__bind__isotp& operator=(const SocketCAN__bind__isotp& other_value);
  boolean operator==(const SocketCAN__bind__isotp& other_value) const;
  inline boolean operator!=(const SocketCAN__bind__isotp& 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& if__index()
    {return field_if__index;}
  inline const INTEGER& if__index() const
    {return field_if__index;}
  inline OCTETSTRING& rx__can__id()
    {return field_rx__can__id;}
  inline const OCTETSTRING& rx__can__id() const
    {return field_rx__can__id;}
  inline OCTETSTRING& tx__can__id()
    {return field_tx__can__id;}
  inline const OCTETSTRING& tx__can__id() const
    {return field_tx__can__id;}
  inline int size_of() const
    {return 3;}
  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 SocketCAN__bind__isotp_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__bind__isotp_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__bind__isotp& other_value);
void copy_template(const SocketCAN__bind__isotp_template& other_value);

public:
SocketCAN__bind__isotp_template();
SocketCAN__bind__isotp_template(template_sel other_value);
SocketCAN__bind__isotp_template(const SocketCAN__bind__isotp& other_value);
SocketCAN__bind__isotp_template(const OPTIONAL<SocketCAN__bind__isotp>& other_value);
SocketCAN__bind__isotp_template(const SocketCAN__bind__isotp_template& other_value);
~SocketCAN__bind__isotp_template();
SocketCAN__bind__isotp_template& operator=(template_sel other_value);
SocketCAN__bind__isotp_template& operator=(const SocketCAN__bind__isotp& other_value);
SocketCAN__bind__isotp_template& operator=(const OPTIONAL<SocketCAN__bind__isotp>& other_value);
SocketCAN__bind__isotp_template& operator=(const SocketCAN__bind__isotp_template& other_value);
boolean match(const SocketCAN__bind__isotp& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__bind__isotp valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__bind__isotp_template& list_item(unsigned int list_index) const;
INTEGER_template& if__index();
const INTEGER_template& if__index() const;
OCTETSTRING_template& rx__can__id();
const OCTETSTRING_template& rx__can__id() const;
OCTETSTRING_template& tx__can__id();
const OCTETSTRING_template& tx__can__id() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__bind__isotp& 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 SocketCAN__bindu : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_raw = 1, ALT_isotp = 2 };
private:
union_selection_type union_selection;
union {
SocketCAN__bind__raw *field_raw;
SocketCAN__bind__isotp *field_isotp;
};
void copy_value(const SocketCAN__bindu& other_value);

public:
SocketCAN__bindu();
SocketCAN__bindu(const SocketCAN__bindu& other_value);
~SocketCAN__bindu();
SocketCAN__bindu& operator=(const SocketCAN__bindu& other_value);
boolean operator==(const SocketCAN__bindu& other_value) const;
inline boolean operator!=(const SocketCAN__bindu& other_value) const { return !(*this == other_value); }
SocketCAN__bind__raw& raw();
const SocketCAN__bind__raw& raw() const;
SocketCAN__bind__isotp& isotp();
const SocketCAN__bind__isotp& isotp() 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 SocketCAN__bindu_template : public Base_Template {
union {
struct {
SocketCAN__bindu::union_selection_type union_selection;
union {
SocketCAN__bind__raw_template *field_raw;
SocketCAN__bind__isotp_template *field_isotp;
};
} single_value;
struct {
unsigned int n_values;
SocketCAN__bindu_template *list_value;
} value_list;
};
void copy_value(const SocketCAN__bindu& other_value);

void copy_template(const SocketCAN__bindu_template& other_value);

public:
SocketCAN__bindu_template();
SocketCAN__bindu_template(template_sel other_value);
SocketCAN__bindu_template(const SocketCAN__bindu& other_value);
SocketCAN__bindu_template(const OPTIONAL<SocketCAN__bindu>& other_value);
SocketCAN__bindu_template(const SocketCAN__bindu_template& other_value);
~SocketCAN__bindu_template();
void clean_up();
SocketCAN__bindu_template& operator=(template_sel other_value);
SocketCAN__bindu_template& operator=(const SocketCAN__bindu& other_value);
SocketCAN__bindu_template& operator=(const OPTIONAL<SocketCAN__bindu>& other_value);
SocketCAN__bindu_template& operator=(const SocketCAN__bindu_template& other_value);
boolean match(const SocketCAN__bindu& other_value, boolean legacy = FALSE) const;
boolean is_value() const;SocketCAN__bindu valueof() const;
SocketCAN__bindu_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__bind__raw_template& raw();
const SocketCAN__bind__raw_template& raw() const;
SocketCAN__bind__isotp_template& isotp();
const SocketCAN__bind__isotp_template& isotp() const;
boolean ischosen(SocketCAN__bindu::union_selection_type checked_selection) const;
void log() const;
void log_match(const SocketCAN__bindu& 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 SocketCAN__bind {
  INTEGER field_id;
  SocketCAN__bindu field_bindu;
public:
  SocketCAN__bind();
  SocketCAN__bind(const INTEGER& par_id,
    const SocketCAN__bindu& par_bindu);
  SocketCAN__bind(const SocketCAN__bind& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__bind& operator=(const SocketCAN__bind& other_value);
  boolean operator==(const SocketCAN__bind& other_value) const;
  inline boolean operator!=(const SocketCAN__bind& 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 SocketCAN__bindu& bindu()
    {return field_bindu;}
  inline const SocketCAN__bindu& bindu() const
    {return field_bindu;}
  inline int size_of() const
    {return 2;}
  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 SocketCAN__bind_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__bind_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__bind& other_value);
void copy_template(const SocketCAN__bind_template& other_value);

public:
SocketCAN__bind_template();
SocketCAN__bind_template(template_sel other_value);
SocketCAN__bind_template(const SocketCAN__bind& other_value);
SocketCAN__bind_template(const OPTIONAL<SocketCAN__bind>& other_value);
SocketCAN__bind_template(const SocketCAN__bind_template& other_value);
~SocketCAN__bind_template();
SocketCAN__bind_template& operator=(template_sel other_value);
SocketCAN__bind_template& operator=(const SocketCAN__bind& other_value);
SocketCAN__bind_template& operator=(const OPTIONAL<SocketCAN__bind>& other_value);
SocketCAN__bind_template& operator=(const SocketCAN__bind_template& other_value);
boolean match(const SocketCAN__bind& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__bind valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__bind_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
SocketCAN__bindu_template& bindu();
const SocketCAN__bindu_template& bindu() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__bind& 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 SocketCAN__bind__result {
  SocketCAN__Result field_result;
public:
  SocketCAN__bind__result();
  SocketCAN__bind__result(const SocketCAN__Result& par_result);
  SocketCAN__bind__result(const SocketCAN__bind__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__bind__result& operator=(const SocketCAN__bind__result& other_value);
  boolean operator==(const SocketCAN__bind__result& other_value) const;
  inline boolean operator!=(const SocketCAN__bind__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 SocketCAN__Result& result()
    {return field_result;}
  inline const SocketCAN__Result& result() const
    {return field_result;}
  inline int size_of() const
    {return 1;}
  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 SocketCAN__bind__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__bind__result_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__bind__result& other_value);
void copy_template(const SocketCAN__bind__result_template& other_value);

public:
SocketCAN__bind__result_template();
SocketCAN__bind__result_template(template_sel other_value);
SocketCAN__bind__result_template(const SocketCAN__bind__result& other_value);
SocketCAN__bind__result_template(const OPTIONAL<SocketCAN__bind__result>& other_value);
SocketCAN__bind__result_template(const SocketCAN__bind__result_template& other_value);
~SocketCAN__bind__result_template();
SocketCAN__bind__result_template& operator=(template_sel other_value);
SocketCAN__bind__result_template& operator=(const SocketCAN__bind__result& other_value);
SocketCAN__bind__result_template& operator=(const OPTIONAL<SocketCAN__bind__result>& other_value);
SocketCAN__bind__result_template& operator=(const SocketCAN__bind__result_template& other_value);
boolean match(const SocketCAN__bind__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__bind__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__bind__result_template& list_item(unsigned int list_index) const;
SocketCAN__Result_template& result();
const SocketCAN__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__bind__result& 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 SocketCAN__send__data {
  INTEGER field_id;
  OPTIONAL<SocketCAN__send__data__ifu> field_ifu;
  SocketCAN__CAN__or__CAN__FD__frame field_frame;
public:
  SocketCAN__send__data();
  SocketCAN__send__data(const INTEGER& par_id,
    const OPTIONAL<SocketCAN__send__data__ifu>& par_ifu,
    const SocketCAN__CAN__or__CAN__FD__frame& par_frame);
  SocketCAN__send__data(const SocketCAN__send__data& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__send__data& operator=(const SocketCAN__send__data& other_value);
  boolean operator==(const SocketCAN__send__data& other_value) const;
  inline boolean operator!=(const SocketCAN__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 INTEGER& id()
    {return field_id;}
  inline const INTEGER& id() const
    {return field_id;}
  inline OPTIONAL<SocketCAN__send__data__ifu>& ifu()
    {return field_ifu;}
  inline const OPTIONAL<SocketCAN__send__data__ifu>& ifu() const
    {return field_ifu;}
  inline SocketCAN__CAN__or__CAN__FD__frame& frame()
    {return field_frame;}
  inline const SocketCAN__CAN__or__CAN__FD__frame& frame() const
    {return field_frame;}
  int size_of() const;
  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 SocketCAN__send__data_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__send__data_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__send__data& other_value);
void copy_template(const SocketCAN__send__data_template& other_value);

public:
SocketCAN__send__data_template();
SocketCAN__send__data_template(template_sel other_value);
SocketCAN__send__data_template(const SocketCAN__send__data& other_value);
SocketCAN__send__data_template(const OPTIONAL<SocketCAN__send__data>& other_value);
SocketCAN__send__data_template(const SocketCAN__send__data_template& other_value);
~SocketCAN__send__data_template();
SocketCAN__send__data_template& operator=(template_sel other_value);
SocketCAN__send__data_template& operator=(const SocketCAN__send__data& other_value);
SocketCAN__send__data_template& operator=(const OPTIONAL<SocketCAN__send__data>& other_value);
SocketCAN__send__data_template& operator=(const SocketCAN__send__data_template& other_value);
boolean match(const SocketCAN__send__data& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__send__data valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__send__data_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
SocketCAN__send__data__ifu_template& ifu();
const SocketCAN__send__data__ifu_template& ifu() const;
SocketCAN__CAN__or__CAN__FD__frame_template& frame();
const SocketCAN__CAN__or__CAN__FD__frame_template& frame() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__send__data& 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 SocketCAN__send__data__result {
  SocketCAN__Result field_result;
public:
  SocketCAN__send__data__result();
  SocketCAN__send__data__result(const SocketCAN__Result& par_result);
  SocketCAN__send__data__result(const SocketCAN__send__data__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__send__data__result& operator=(const SocketCAN__send__data__result& other_value);
  boolean operator==(const SocketCAN__send__data__result& other_value) const;
  inline boolean operator!=(const SocketCAN__send__data__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 SocketCAN__Result& result()
    {return field_result;}
  inline const SocketCAN__Result& result() const
    {return field_result;}
  inline int size_of() const
    {return 1;}
  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 SocketCAN__send__data__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__send__data__result_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__send__data__result& other_value);
void copy_template(const SocketCAN__send__data__result_template& other_value);

public:
SocketCAN__send__data__result_template();
SocketCAN__send__data__result_template(template_sel other_value);
SocketCAN__send__data__result_template(const SocketCAN__send__data__result& other_value);
SocketCAN__send__data__result_template(const OPTIONAL<SocketCAN__send__data__result>& other_value);
SocketCAN__send__data__result_template(const SocketCAN__send__data__result_template& other_value);
~SocketCAN__send__data__result_template();
SocketCAN__send__data__result_template& operator=(template_sel other_value);
SocketCAN__send__data__result_template& operator=(const SocketCAN__send__data__result& other_value);
SocketCAN__send__data__result_template& operator=(const OPTIONAL<SocketCAN__send__data__result>& other_value);
SocketCAN__send__data__result_template& operator=(const SocketCAN__send__data__result_template& other_value);
boolean match(const SocketCAN__send__data__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__send__data__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__send__data__result_template& list_item(unsigned int list_index) const;
SocketCAN__Result_template& result();
const SocketCAN__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__send__data__result& 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 SocketCAN__write__data {
  INTEGER field_id;
  Bcm::SocketCAN__bcm__frame field_bcm__tx__msg;
public:
  SocketCAN__write__data();
  SocketCAN__write__data(const INTEGER& par_id,
    const Bcm::SocketCAN__bcm__frame& par_bcm__tx__msg);
  SocketCAN__write__data(const SocketCAN__write__data& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__write__data& operator=(const SocketCAN__write__data& other_value);
  boolean operator==(const SocketCAN__write__data& other_value) const;
  inline boolean operator!=(const SocketCAN__write__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 INTEGER& id()
    {return field_id;}
  inline const INTEGER& id() const
    {return field_id;}
  inline Bcm::SocketCAN__bcm__frame& bcm__tx__msg()
    {return field_bcm__tx__msg;}
  inline const Bcm::SocketCAN__bcm__frame& bcm__tx__msg() const
    {return field_bcm__tx__msg;}
  inline int size_of() const
    {return 2;}
  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 SocketCAN__write__data_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__write__data_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__write__data& other_value);
void copy_template(const SocketCAN__write__data_template& other_value);

public:
SocketCAN__write__data_template();
SocketCAN__write__data_template(template_sel other_value);
SocketCAN__write__data_template(const SocketCAN__write__data& other_value);
SocketCAN__write__data_template(const OPTIONAL<SocketCAN__write__data>& other_value);
SocketCAN__write__data_template(const SocketCAN__write__data_template& other_value);
~SocketCAN__write__data_template();
SocketCAN__write__data_template& operator=(template_sel other_value);
SocketCAN__write__data_template& operator=(const SocketCAN__write__data& other_value);
SocketCAN__write__data_template& operator=(const OPTIONAL<SocketCAN__write__data>& other_value);
SocketCAN__write__data_template& operator=(const SocketCAN__write__data_template& other_value);
boolean match(const SocketCAN__write__data& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__write__data valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__write__data_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
Bcm::SocketCAN__bcm__frame_template& bcm__tx__msg();
const Bcm::SocketCAN__bcm__frame_template& bcm__tx__msg() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__write__data& 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 SocketCAN__write__data__result {
  SocketCAN__Result field_result;
public:
  SocketCAN__write__data__result();
  SocketCAN__write__data__result(const SocketCAN__Result& par_result);
  SocketCAN__write__data__result(const SocketCAN__write__data__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__write__data__result& operator=(const SocketCAN__write__data__result& other_value);
  boolean operator==(const SocketCAN__write__data__result& other_value) const;
  inline boolean operator!=(const SocketCAN__write__data__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 SocketCAN__Result& result()
    {return field_result;}
  inline const SocketCAN__Result& result() const
    {return field_result;}
  inline int size_of() const
    {return 1;}
  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 SocketCAN__write__data__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__write__data__result_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__write__data__result& other_value);
void copy_template(const SocketCAN__write__data__result_template& other_value);

public:
SocketCAN__write__data__result_template();
SocketCAN__write__data__result_template(template_sel other_value);
SocketCAN__write__data__result_template(const SocketCAN__write__data__result& other_value);
SocketCAN__write__data__result_template(const OPTIONAL<SocketCAN__write__data__result>& other_value);
SocketCAN__write__data__result_template(const SocketCAN__write__data__result_template& other_value);
~SocketCAN__write__data__result_template();
SocketCAN__write__data__result_template& operator=(template_sel other_value);
SocketCAN__write__data__result_template& operator=(const SocketCAN__write__data__result& other_value);
SocketCAN__write__data__result_template& operator=(const OPTIONAL<SocketCAN__write__data__result>& other_value);
SocketCAN__write__data__result_template& operator=(const SocketCAN__write__data__result_template& other_value);
boolean match(const SocketCAN__write__data__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__write__data__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__write__data__result_template& list_item(unsigned int list_index) const;
SocketCAN__Result_template& result();
const SocketCAN__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__write__data__result& 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 SocketCAN__write__isotp {
  INTEGER field_id;
  OCTETSTRING field_pdu;
public:
  SocketCAN__write__isotp();
  SocketCAN__write__isotp(const INTEGER& par_id,
    const OCTETSTRING& par_pdu);
  SocketCAN__write__isotp(const SocketCAN__write__isotp& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__write__isotp& operator=(const SocketCAN__write__isotp& other_value);
  boolean operator==(const SocketCAN__write__isotp& other_value) const;
  inline boolean operator!=(const SocketCAN__write__isotp& 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 OCTETSTRING& pdu()
    {return field_pdu;}
  inline const OCTETSTRING& pdu() const
    {return field_pdu;}
  inline int size_of() const
    {return 2;}
  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 SocketCAN__write__isotp_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__write__isotp_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__write__isotp& other_value);
void copy_template(const SocketCAN__write__isotp_template& other_value);

public:
SocketCAN__write__isotp_template();
SocketCAN__write__isotp_template(template_sel other_value);
SocketCAN__write__isotp_template(const SocketCAN__write__isotp& other_value);
SocketCAN__write__isotp_template(const OPTIONAL<SocketCAN__write__isotp>& other_value);
SocketCAN__write__isotp_template(const SocketCAN__write__isotp_template& other_value);
~SocketCAN__write__isotp_template();
SocketCAN__write__isotp_template& operator=(template_sel other_value);
SocketCAN__write__isotp_template& operator=(const SocketCAN__write__isotp& other_value);
SocketCAN__write__isotp_template& operator=(const OPTIONAL<SocketCAN__write__isotp>& other_value);
SocketCAN__write__isotp_template& operator=(const SocketCAN__write__isotp_template& other_value);
boolean match(const SocketCAN__write__isotp& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__write__isotp valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__write__isotp_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
OCTETSTRING_template& pdu();
const OCTETSTRING_template& pdu() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__write__isotp& 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 SocketCAN__write__isotp__result {
  SocketCAN__Result field_result;
public:
  SocketCAN__write__isotp__result();
  SocketCAN__write__isotp__result(const SocketCAN__Result& par_result);
  SocketCAN__write__isotp__result(const SocketCAN__write__isotp__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__write__isotp__result& operator=(const SocketCAN__write__isotp__result& other_value);
  boolean operator==(const SocketCAN__write__isotp__result& other_value) const;
  inline boolean operator!=(const SocketCAN__write__isotp__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 SocketCAN__Result& result()
    {return field_result;}
  inline const SocketCAN__Result& result() const
    {return field_result;}
  inline int size_of() const
    {return 1;}
  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 SocketCAN__write__isotp__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__write__isotp__result_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__write__isotp__result& other_value);
void copy_template(const SocketCAN__write__isotp__result_template& other_value);

public:
SocketCAN__write__isotp__result_template();
SocketCAN__write__isotp__result_template(template_sel other_value);
SocketCAN__write__isotp__result_template(const SocketCAN__write__isotp__result& other_value);
SocketCAN__write__isotp__result_template(const OPTIONAL<SocketCAN__write__isotp__result>& other_value);
SocketCAN__write__isotp__result_template(const SocketCAN__write__isotp__result_template& other_value);
~SocketCAN__write__isotp__result_template();
SocketCAN__write__isotp__result_template& operator=(template_sel other_value);
SocketCAN__write__isotp__result_template& operator=(const SocketCAN__write__isotp__result& other_value);
SocketCAN__write__isotp__result_template& operator=(const OPTIONAL<SocketCAN__write__isotp__result>& other_value);
SocketCAN__write__isotp__result_template& operator=(const SocketCAN__write__isotp__result_template& other_value);
boolean match(const SocketCAN__write__isotp__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__write__isotp__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__write__isotp__result_template& list_item(unsigned int list_index) const;
SocketCAN__Result_template& result();
const SocketCAN__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__write__isotp__result& 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 SocketCAN__receive__CAN__or__CAN__FD__frame {
  INTEGER field_id;
  SocketCAN__ifr field_ifr;
  SocketCAN__CAN__or__CAN__FD__frame field_frame;
  SocketCAN__timeval field_timestamp;
public:
  SocketCAN__receive__CAN__or__CAN__FD__frame();
  SocketCAN__receive__CAN__or__CAN__FD__frame(const INTEGER& par_id,
    const SocketCAN__ifr& par_ifr,
    const SocketCAN__CAN__or__CAN__FD__frame& par_frame,
    const SocketCAN__timeval& par_timestamp);
  SocketCAN__receive__CAN__or__CAN__FD__frame(const SocketCAN__receive__CAN__or__CAN__FD__frame& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__receive__CAN__or__CAN__FD__frame& operator=(const SocketCAN__receive__CAN__or__CAN__FD__frame& other_value);
  boolean operator==(const SocketCAN__receive__CAN__or__CAN__FD__frame& other_value) const;
  inline boolean operator!=(const SocketCAN__receive__CAN__or__CAN__FD__frame& 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 SocketCAN__ifr& ifr()
    {return field_ifr;}
  inline const SocketCAN__ifr& ifr() const
    {return field_ifr;}
  inline SocketCAN__CAN__or__CAN__FD__frame& frame()
    {return field_frame;}
  inline const SocketCAN__CAN__or__CAN__FD__frame& frame() const
    {return field_frame;}
  inline SocketCAN__timeval& timestamp()
    {return field_timestamp;}
  inline const SocketCAN__timeval& timestamp() const
    {return field_timestamp;}
  inline int size_of() const
    {return 4;}
  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 SocketCAN__receive__CAN__or__CAN__FD__frame_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__receive__CAN__or__CAN__FD__frame_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__receive__CAN__or__CAN__FD__frame& other_value);
void copy_template(const SocketCAN__receive__CAN__or__CAN__FD__frame_template& other_value);

public:
SocketCAN__receive__CAN__or__CAN__FD__frame_template();
SocketCAN__receive__CAN__or__CAN__FD__frame_template(template_sel other_value);
SocketCAN__receive__CAN__or__CAN__FD__frame_template(const SocketCAN__receive__CAN__or__CAN__FD__frame& other_value);
SocketCAN__receive__CAN__or__CAN__FD__frame_template(const OPTIONAL<SocketCAN__receive__CAN__or__CAN__FD__frame>& other_value);
SocketCAN__receive__CAN__or__CAN__FD__frame_template(const SocketCAN__receive__CAN__or__CAN__FD__frame_template& other_value);
~SocketCAN__receive__CAN__or__CAN__FD__frame_template();
SocketCAN__receive__CAN__or__CAN__FD__frame_template& operator=(template_sel other_value);
SocketCAN__receive__CAN__or__CAN__FD__frame_template& operator=(const SocketCAN__receive__CAN__or__CAN__FD__frame& other_value);
SocketCAN__receive__CAN__or__CAN__FD__frame_template& operator=(const OPTIONAL<SocketCAN__receive__CAN__or__CAN__FD__frame>& other_value);
SocketCAN__receive__CAN__or__CAN__FD__frame_template& operator=(const SocketCAN__receive__CAN__or__CAN__FD__frame_template& other_value);
boolean match(const SocketCAN__receive__CAN__or__CAN__FD__frame& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__receive__CAN__or__CAN__FD__frame valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__receive__CAN__or__CAN__FD__frame_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
SocketCAN__ifr_template& ifr();
const SocketCAN__ifr_template& ifr() const;
SocketCAN__CAN__or__CAN__FD__frame_template& frame();
const SocketCAN__CAN__or__CAN__FD__frame_template& frame() const;
SocketCAN__timeval_template& timestamp();
const SocketCAN__timeval_template& timestamp() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__receive__CAN__or__CAN__FD__frame& 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 SocketCAN__receive__BCM__message {
  INTEGER field_id;
  SocketCAN__ifr field_ifr;
  Bcm::SocketCAN__bcm__frame field_frame;
public:
  SocketCAN__receive__BCM__message();
  SocketCAN__receive__BCM__message(const INTEGER& par_id,
    const SocketCAN__ifr& par_ifr,
    const Bcm::SocketCAN__bcm__frame& par_frame);
  SocketCAN__receive__BCM__message(const SocketCAN__receive__BCM__message& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__receive__BCM__message& operator=(const SocketCAN__receive__BCM__message& other_value);
  boolean operator==(const SocketCAN__receive__BCM__message& other_value) const;
  inline boolean operator!=(const SocketCAN__receive__BCM__message& 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 SocketCAN__ifr& ifr()
    {return field_ifr;}
  inline const SocketCAN__ifr& ifr() const
    {return field_ifr;}
  inline Bcm::SocketCAN__bcm__frame& frame()
    {return field_frame;}
  inline const Bcm::SocketCAN__bcm__frame& frame() const
    {return field_frame;}
  inline int size_of() const
    {return 3;}
  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 SocketCAN__receive__BCM__message_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__receive__BCM__message_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__receive__BCM__message& other_value);
void copy_template(const SocketCAN__receive__BCM__message_template& other_value);

public:
SocketCAN__receive__BCM__message_template();
SocketCAN__receive__BCM__message_template(template_sel other_value);
SocketCAN__receive__BCM__message_template(const SocketCAN__receive__BCM__message& other_value);
SocketCAN__receive__BCM__message_template(const OPTIONAL<SocketCAN__receive__BCM__message>& other_value);
SocketCAN__receive__BCM__message_template(const SocketCAN__receive__BCM__message_template& other_value);
~SocketCAN__receive__BCM__message_template();
SocketCAN__receive__BCM__message_template& operator=(template_sel other_value);
SocketCAN__receive__BCM__message_template& operator=(const SocketCAN__receive__BCM__message& other_value);
SocketCAN__receive__BCM__message_template& operator=(const OPTIONAL<SocketCAN__receive__BCM__message>& other_value);
SocketCAN__receive__BCM__message_template& operator=(const SocketCAN__receive__BCM__message_template& other_value);
boolean match(const SocketCAN__receive__BCM__message& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__receive__BCM__message valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__receive__BCM__message_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
SocketCAN__ifr_template& ifr();
const SocketCAN__ifr_template& ifr() const;
Bcm::SocketCAN__bcm__frame_template& frame();
const Bcm::SocketCAN__bcm__frame_template& frame() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__receive__BCM__message& 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 SocketCAN__receive__isotp__pdu {
  INTEGER field_id;
  SocketCAN__ifr field_ifr;
  OCTETSTRING field_pdu;
public:
  SocketCAN__receive__isotp__pdu();
  SocketCAN__receive__isotp__pdu(const INTEGER& par_id,
    const SocketCAN__ifr& par_ifr,
    const OCTETSTRING& par_pdu);
  SocketCAN__receive__isotp__pdu(const SocketCAN__receive__isotp__pdu& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__receive__isotp__pdu& operator=(const SocketCAN__receive__isotp__pdu& other_value);
  boolean operator==(const SocketCAN__receive__isotp__pdu& other_value) const;
  inline boolean operator!=(const SocketCAN__receive__isotp__pdu& 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 SocketCAN__ifr& ifr()
    {return field_ifr;}
  inline const SocketCAN__ifr& ifr() const
    {return field_ifr;}
  inline OCTETSTRING& pdu()
    {return field_pdu;}
  inline const OCTETSTRING& pdu() const
    {return field_pdu;}
  inline int size_of() const
    {return 3;}
  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 SocketCAN__receive__isotp__pdu_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__receive__isotp__pdu_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__receive__isotp__pdu& other_value);
void copy_template(const SocketCAN__receive__isotp__pdu_template& other_value);

public:
SocketCAN__receive__isotp__pdu_template();
SocketCAN__receive__isotp__pdu_template(template_sel other_value);
SocketCAN__receive__isotp__pdu_template(const SocketCAN__receive__isotp__pdu& other_value);
SocketCAN__receive__isotp__pdu_template(const OPTIONAL<SocketCAN__receive__isotp__pdu>& other_value);
SocketCAN__receive__isotp__pdu_template(const SocketCAN__receive__isotp__pdu_template& other_value);
~SocketCAN__receive__isotp__pdu_template();
SocketCAN__receive__isotp__pdu_template& operator=(template_sel other_value);
SocketCAN__receive__isotp__pdu_template& operator=(const SocketCAN__receive__isotp__pdu& other_value);
SocketCAN__receive__isotp__pdu_template& operator=(const OPTIONAL<SocketCAN__receive__isotp__pdu>& other_value);
SocketCAN__receive__isotp__pdu_template& operator=(const SocketCAN__receive__isotp__pdu_template& other_value);
boolean match(const SocketCAN__receive__isotp__pdu& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__receive__isotp__pdu valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__receive__isotp__pdu_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
SocketCAN__ifr_template& ifr();
const SocketCAN__ifr_template& ifr() const;
OCTETSTRING_template& pdu();
const OCTETSTRING_template& pdu() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__receive__isotp__pdu& 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 CAN__RAW__filters : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
Raw::CAN__RAW__filter **value_elements;
} *val_ptr;

static const Raw::CAN__RAW__filter UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const CAN__RAW__filters& other_value);

public:
  typedef Raw::CAN__RAW__filter of_type;
CAN__RAW__filters();
CAN__RAW__filters(null_type other_value);
CAN__RAW__filters(const CAN__RAW__filters& other_value);
~CAN__RAW__filters();

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

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

Raw::CAN__RAW__filter& operator[](int index_value);
Raw::CAN__RAW__filter& operator[](const INTEGER& index_value);
const Raw::CAN__RAW__filter& operator[](int index_value) const;
const Raw::CAN__RAW__filter& operator[](const INTEGER& index_value) const;

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

CAN__RAW__filters operator+(const CAN__RAW__filters& other_value) const;

CAN__RAW__filters substr(int index, int returncount) const;

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

CAN__RAW__filters replace(int index, int len, const CAN__RAW__filters_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_param(Module_Param& param);
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class CAN__RAW__filters_template : public Record_Of_Template {
union {
struct {
int n_elements;
Raw::CAN__RAW__filter_template **value_elements;
} single_value;
struct {
unsigned int n_values;
CAN__RAW__filters_template *list_value;
} value_list;
};
void copy_value(const CAN__RAW__filters& other_value);
void copy_template(const CAN__RAW__filters_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:
CAN__RAW__filters_template();
CAN__RAW__filters_template(template_sel other_value);
CAN__RAW__filters_template(null_type other_value);
CAN__RAW__filters_template(const CAN__RAW__filters& other_value);
CAN__RAW__filters_template(const OPTIONAL<CAN__RAW__filters>& other_value);
CAN__RAW__filters_template(const CAN__RAW__filters_template& other_value);
~CAN__RAW__filters_template();

void clean_up();
CAN__RAW__filters_template& operator=(template_sel other_value);
CAN__RAW__filters_template& operator=(null_type other_value);
CAN__RAW__filters_template& operator=(const CAN__RAW__filters& other_value);
CAN__RAW__filters_template& operator=(const OPTIONAL<CAN__RAW__filters>& other_value);
CAN__RAW__filters_template& operator=(const CAN__RAW__filters_template& other_value);

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

CAN__RAW__filters replace(int index, int len, const CAN__RAW__filters_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
CAN__RAW__filters_template& list_item(unsigned int list_index);
void log() const;
void log_match(const CAN__RAW__filters& 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 SocketCAN__setsockopt__commandu : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_rfilter = 1, ALT_err__mask = 2, ALT_loopback = 3, ALT_recv__own__msgs = 4, ALT_fd__frames = 5, ALT_join__filters = 6 };
private:
union_selection_type union_selection;
union {
CAN__RAW__filters *field_rfilter;
BITSTRING *field_err__mask;
Raw::DisableEnable__enum *field_loopback;
Raw::DisableEnable__enum *field_recv__own__msgs;
Raw::DisableEnable__enum *field_fd__frames;
Raw::DisableEnable__enum *field_join__filters;
};
void copy_value(const SocketCAN__setsockopt__commandu& other_value);

public:
SocketCAN__setsockopt__commandu();
SocketCAN__setsockopt__commandu(const SocketCAN__setsockopt__commandu& other_value);
~SocketCAN__setsockopt__commandu();
SocketCAN__setsockopt__commandu& operator=(const SocketCAN__setsockopt__commandu& other_value);
boolean operator==(const SocketCAN__setsockopt__commandu& other_value) const;
inline boolean operator!=(const SocketCAN__setsockopt__commandu& other_value) const { return !(*this == other_value); }
CAN__RAW__filters& rfilter();
const CAN__RAW__filters& rfilter() const;
BITSTRING& err__mask();
const BITSTRING& err__mask() const;
Raw::DisableEnable__enum& loopback();
const Raw::DisableEnable__enum& loopback() const;
Raw::DisableEnable__enum& recv__own__msgs();
const Raw::DisableEnable__enum& recv__own__msgs() const;
Raw::DisableEnable__enum& fd__frames();
const Raw::DisableEnable__enum& fd__frames() const;
Raw::DisableEnable__enum& join__filters();
const Raw::DisableEnable__enum& join__filters() 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 SocketCAN__setsockopt__commandu_template : public Base_Template {
union {
struct {
SocketCAN__setsockopt__commandu::union_selection_type union_selection;
union {
CAN__RAW__filters_template *field_rfilter;
BITSTRING_template *field_err__mask;
Raw::DisableEnable__enum_template *field_loopback;
Raw::DisableEnable__enum_template *field_recv__own__msgs;
Raw::DisableEnable__enum_template *field_fd__frames;
Raw::DisableEnable__enum_template *field_join__filters;
};
} single_value;
struct {
unsigned int n_values;
SocketCAN__setsockopt__commandu_template *list_value;
} value_list;
};
void copy_value(const SocketCAN__setsockopt__commandu& other_value);

void copy_template(const SocketCAN__setsockopt__commandu_template& other_value);

public:
SocketCAN__setsockopt__commandu_template();
SocketCAN__setsockopt__commandu_template(template_sel other_value);
SocketCAN__setsockopt__commandu_template(const SocketCAN__setsockopt__commandu& other_value);
SocketCAN__setsockopt__commandu_template(const OPTIONAL<SocketCAN__setsockopt__commandu>& other_value);
SocketCAN__setsockopt__commandu_template(const SocketCAN__setsockopt__commandu_template& other_value);
~SocketCAN__setsockopt__commandu_template();
void clean_up();
SocketCAN__setsockopt__commandu_template& operator=(template_sel other_value);
SocketCAN__setsockopt__commandu_template& operator=(const SocketCAN__setsockopt__commandu& other_value);
SocketCAN__setsockopt__commandu_template& operator=(const OPTIONAL<SocketCAN__setsockopt__commandu>& other_value);
SocketCAN__setsockopt__commandu_template& operator=(const SocketCAN__setsockopt__commandu_template& other_value);
boolean match(const SocketCAN__setsockopt__commandu& other_value, boolean legacy = FALSE) const;
boolean is_value() const;SocketCAN__setsockopt__commandu valueof() const;
SocketCAN__setsockopt__commandu_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
CAN__RAW__filters_template& rfilter();
const CAN__RAW__filters_template& rfilter() const;
BITSTRING_template& err__mask();
const BITSTRING_template& err__mask() const;
Raw::DisableEnable__enum_template& loopback();
const Raw::DisableEnable__enum_template& loopback() const;
Raw::DisableEnable__enum_template& recv__own__msgs();
const Raw::DisableEnable__enum_template& recv__own__msgs() const;
Raw::DisableEnable__enum_template& fd__frames();
const Raw::DisableEnable__enum_template& fd__frames() const;
Raw::DisableEnable__enum_template& join__filters();
const Raw::DisableEnable__enum_template& join__filters() const;
boolean ischosen(SocketCAN__setsockopt__commandu::union_selection_type checked_selection) const;
void log() const;
void log_match(const SocketCAN__setsockopt__commandu& 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 SocketCAN__setsockopt {
  INTEGER field_id;
  SocketCAN__setsockopt__commandu field_command;
public:
  SocketCAN__setsockopt();
  SocketCAN__setsockopt(const INTEGER& par_id,
    const SocketCAN__setsockopt__commandu& par_command);
  SocketCAN__setsockopt(const SocketCAN__setsockopt& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__setsockopt& operator=(const SocketCAN__setsockopt& other_value);
  boolean operator==(const SocketCAN__setsockopt& other_value) const;
  inline boolean operator!=(const SocketCAN__setsockopt& 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 SocketCAN__setsockopt__commandu& command()
    {return field_command;}
  inline const SocketCAN__setsockopt__commandu& command() const
    {return field_command;}
  inline int size_of() const
    {return 2;}
  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 SocketCAN__setsockopt_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__setsockopt_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__setsockopt& other_value);
void copy_template(const SocketCAN__setsockopt_template& other_value);

public:
SocketCAN__setsockopt_template();
SocketCAN__setsockopt_template(template_sel other_value);
SocketCAN__setsockopt_template(const SocketCAN__setsockopt& other_value);
SocketCAN__setsockopt_template(const OPTIONAL<SocketCAN__setsockopt>& other_value);
SocketCAN__setsockopt_template(const SocketCAN__setsockopt_template& other_value);
~SocketCAN__setsockopt_template();
SocketCAN__setsockopt_template& operator=(template_sel other_value);
SocketCAN__setsockopt_template& operator=(const SocketCAN__setsockopt& other_value);
SocketCAN__setsockopt_template& operator=(const OPTIONAL<SocketCAN__setsockopt>& other_value);
SocketCAN__setsockopt_template& operator=(const SocketCAN__setsockopt_template& other_value);
boolean match(const SocketCAN__setsockopt& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__setsockopt valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__setsockopt_template& list_item(unsigned int list_index) const;
INTEGER_template& id();
const INTEGER_template& id() const;
SocketCAN__setsockopt__commandu_template& command();
const SocketCAN__setsockopt__commandu_template& command() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__setsockopt& 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 SocketCAN__setsockopt__result {
  SocketCAN__Result field_result;
public:
  SocketCAN__setsockopt__result();
  SocketCAN__setsockopt__result(const SocketCAN__Result& par_result);
  SocketCAN__setsockopt__result(const SocketCAN__setsockopt__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__setsockopt__result& operator=(const SocketCAN__setsockopt__result& other_value);
  boolean operator==(const SocketCAN__setsockopt__result& other_value) const;
  inline boolean operator!=(const SocketCAN__setsockopt__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 SocketCAN__Result& result()
    {return field_result;}
  inline const SocketCAN__Result& result() const
    {return field_result;}
  inline int size_of() const
    {return 1;}
  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 SocketCAN__setsockopt__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__setsockopt__result_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__setsockopt__result& other_value);
void copy_template(const SocketCAN__setsockopt__result_template& other_value);

public:
SocketCAN__setsockopt__result_template();
SocketCAN__setsockopt__result_template(template_sel other_value);
SocketCAN__setsockopt__result_template(const SocketCAN__setsockopt__result& other_value);
SocketCAN__setsockopt__result_template(const OPTIONAL<SocketCAN__setsockopt__result>& other_value);
SocketCAN__setsockopt__result_template(const SocketCAN__setsockopt__result_template& other_value);
~SocketCAN__setsockopt__result_template();
SocketCAN__setsockopt__result_template& operator=(template_sel other_value);
SocketCAN__setsockopt__result_template& operator=(const SocketCAN__setsockopt__result& other_value);
SocketCAN__setsockopt__result_template& operator=(const OPTIONAL<SocketCAN__setsockopt__result>& other_value);
SocketCAN__setsockopt__result_template& operator=(const SocketCAN__setsockopt__result_template& other_value);
boolean match(const SocketCAN__setsockopt__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__setsockopt__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__setsockopt__result_template& list_item(unsigned int list_index) const;
SocketCAN__Result_template& result();
const SocketCAN__Result_template& result() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__setsockopt__result& 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 SocketCAN__close {
  INTEGER field_id;
public:
  SocketCAN__close();
  SocketCAN__close(const INTEGER& par_id);
  SocketCAN__close(const SocketCAN__close& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__close& operator=(const SocketCAN__close& other_value);
  boolean operator==(const SocketCAN__close& other_value) const;
  inline boolean operator!=(const SocketCAN__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_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
};

class SocketCAN__close_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__close_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__close& other_value);
void copy_template(const SocketCAN__close_template& other_value);

public:
SocketCAN__close_template();
SocketCAN__close_template(template_sel other_value);
SocketCAN__close_template(const SocketCAN__close& other_value);
SocketCAN__close_template(const OPTIONAL<SocketCAN__close>& other_value);
SocketCAN__close_template(const SocketCAN__close_template& other_value);
~SocketCAN__close_template();
SocketCAN__close_template& operator=(template_sel other_value);
SocketCAN__close_template& operator=(const SocketCAN__close& other_value);
SocketCAN__close_template& operator=(const OPTIONAL<SocketCAN__close>& other_value);
SocketCAN__close_template& operator=(const SocketCAN__close_template& other_value);
boolean match(const SocketCAN__close& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__close valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__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 SocketCAN__close& 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;
};


/* Function prototypes */

extern boolean operator==(null_type null_value, const CAN__RAW__filters& other_value);
inline boolean operator!=(null_type null_value, const CAN__RAW__filters& other_value) { return !(null_value == other_value); }

/* Global variable declarations */

extern const XERdescriptor_t SocketCAN__socketid_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__socketid_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__socketid_descr_;
extern const XERdescriptor_t SocketCAN__if__name_xer_;
extern const TTCN_Typedescriptor_t SocketCAN__if__name_descr_;
extern const XERdescriptor_t SocketCAN__if__index_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__if__index_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__if__index_descr_;
extern const XERdescriptor_t SocketCAN__Isotp__PDU_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__Isotp__PDU_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__Isotp__PDU_descr_;
extern const XERdescriptor_t SocketCAN__timeval_tv__sec_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__timeval_tv__sec_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__timeval_tv__sec_descr_;
extern const XERdescriptor_t SocketCAN__timeval_tv__usec_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__timeval_tv__usec_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__timeval_tv__usec_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__timeval_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__CAN__or__CAN__FD__frame_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__ifr_descr_;
extern const XERdescriptor_t SocketCAN__ifr_if__name_xer_;
extern const TTCN_Typedescriptor_t SocketCAN__ifr_if__name_descr_;
extern const XERdescriptor_t SocketCAN__ifr_if__index_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__ifr_if__index_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__ifr_if__index_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__if__any_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__send__data__ifu_descr_;
extern const XERdescriptor_t SocketCAN__send__data__ifu_if__name_xer_;
extern const TTCN_Typedescriptor_t SocketCAN__send__data__ifu_if__name_descr_;
extern const XERdescriptor_t SocketCAN__send__data__ifu_if__index_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__send__data__ifu_if__index_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__send__data__ifu_if__index_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__ioctl__ifu_descr_;
extern const XERdescriptor_t SocketCAN__ioctl__ifu_if__name_xer_;
extern const TTCN_Typedescriptor_t SocketCAN__ioctl__ifu_if__name_descr_;
extern const XERdescriptor_t SocketCAN__ioctl__ifu_if__index_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__ioctl__ifu_if__index_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__ioctl__ifu_if__index_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__Result__code_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__Result_descr_;
extern const XERdescriptor_t SocketCAN__Result_err_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__Result_err_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__Result_err_descr_;
extern const XERdescriptor_t SocketCAN__Result_err__text_xer_;
extern const TTCN_Typedescriptor_t SocketCAN__Result_err__text_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__socket_descr_;
extern const XERdescriptor_t SocketCAN__socket__result_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__socket__result_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__socket__result_id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__socket__result_descr_;
extern const XERdescriptor_t SocketCAN__ioctl_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__ioctl_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__ioctl_id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__ioctl_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__ioctl__result_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__connectu_descr_;
extern const XERdescriptor_t SocketCAN__connect__bcm_if__index_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__connect__bcm_if__index_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__connect__bcm_if__index_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__connect__bcm_descr_;
extern const XERdescriptor_t SocketCAN__connect_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__connect_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__connect_id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__connect_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__connect__result_descr_;
extern const XERdescriptor_t SocketCAN__bind__raw_if__index_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__bind__raw_if__index_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__bind__raw_if__index_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__bind__raw_descr_;
extern const XERdescriptor_t SocketCAN__bind__isotp_if__index_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__bind__isotp_if__index_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__bind__isotp_if__index_descr_;
extern const XERdescriptor_t SocketCAN__bind__isotp_rx__can__id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__bind__isotp_rx__can__id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__bind__isotp_rx__can__id_descr_;
extern const XERdescriptor_t SocketCAN__bind__isotp_tx__can__id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__bind__isotp_tx__can__id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__bind__isotp_tx__can__id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__bind__isotp_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__bindu_descr_;
extern const XERdescriptor_t SocketCAN__bind_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__bind_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__bind_id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__bind_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__bind__result_descr_;
extern const XERdescriptor_t SocketCAN__send__data_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__send__data_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__send__data_id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__send__data_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__send__data__result_descr_;
extern const XERdescriptor_t SocketCAN__write__data_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__write__data_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__write__data_id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__write__data_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__write__data__result_descr_;
extern const XERdescriptor_t SocketCAN__write__isotp_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__write__isotp_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__write__isotp_id_descr_;
extern const XERdescriptor_t SocketCAN__write__isotp_pdu_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__write__isotp_pdu_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__write__isotp_pdu_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__write__isotp_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__write__isotp__result_descr_;
extern const XERdescriptor_t SocketCAN__receive__CAN__or__CAN__FD__frame_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__receive__CAN__or__CAN__FD__frame_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__receive__CAN__or__CAN__FD__frame_id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__receive__CAN__or__CAN__FD__frame_descr_;
extern const XERdescriptor_t SocketCAN__receive__BCM__message_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__receive__BCM__message_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__receive__BCM__message_id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__receive__BCM__message_descr_;
extern const XERdescriptor_t SocketCAN__receive__isotp__pdu_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__receive__isotp__pdu_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__receive__isotp__pdu_id_descr_;
extern const XERdescriptor_t SocketCAN__receive__isotp__pdu_pdu_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__receive__isotp__pdu_pdu_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__receive__isotp__pdu_pdu_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__receive__isotp__pdu_descr_;
extern const TTCN_Typedescriptor_t CAN__RAW__filters_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__setsockopt__commandu_descr_;
extern const XERdescriptor_t SocketCAN__setsockopt__commandu_err__mask_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__setsockopt__commandu_err__mask_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__setsockopt__commandu_err__mask_descr_;
extern const XERdescriptor_t SocketCAN__setsockopt_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__setsockopt_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__setsockopt_id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__setsockopt_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__setsockopt__result_descr_;
extern const XERdescriptor_t SocketCAN__close_id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__close_id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__close_id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__close_descr_;
extern TTCN_Module module_object;

} /* end of namespace */

#endif