// 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 Bcm_HH
#define Bcm_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 "Can.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 Bcm_HH
#endif

namespace Bcm {

/* Forward declarations of classes */

class BcmFlagsBitIndex__enum;
class BcmFlagsBitIndex__enum_template;
class BcmFlags__enum;
class BcmFlags__enum_template;
class BcmOpcode__enum;
class BcmOpcode__enum_template;
class Bcm__timeval;
class Bcm__timeval_template;
class SocketCAN__bcm__frame_frames;
class SocketCAN__bcm__frame_frames_template;
class SocketCAN__bcm__frame_frames_can__frame;
class SocketCAN__bcm__frame_frames_can__frame_template;
class SocketCAN__bcm__frame_frames_canfd__frame;
class SocketCAN__bcm__frame_frames_canfd__frame_template;
class SocketCAN__bcm__frame;
class SocketCAN__bcm__frame_template;

} /* end of namespace */

#ifndef Bcm_HH
#define Bcm_HH

namespace Bcm {

/* Type definitions */

typedef INTEGER Bcm__long;
typedef INTEGER_template Bcm__long_template;

/* Class definitions */

class BcmFlagsBitIndex__enum : public Base_Type { // enum
friend class BcmFlagsBitIndex__enum_template;
public:
enum enum_type { e__CAN__BCM__SETTIMER__BITINDEX = 0, e__CAN__BCM__STARTTIMER__BITINDEX = 1, e__CAN__BCM__TX__COUNTEVT__BITINDEX = 2, e__CAN__BCM__TX__ANNOUNCE__BITINDEX = 3, e__CAN__BCM__TX__CP__CAN__ID__BITINDEX = 4, e__CAN__BCM__RX__FILTER__ID__BITINDEX = 5, e__CAN__BCM__RX__CHECK__DLC__BITINDEX = 6, e__CAN__BCM__RX__NO__AUTOTIMER__BITINDEX = 7, e__CAN__BCM__RX__ANNOUNCE__RESUME__BITINDEX = 8, e__CAN__BCM__TX__RESET__MULTI__IDX__BITINDEX = 9, e__CAN__BCM__RX__RTR__FRAME__BITINDEX = 10, UNKNOWN_VALUE = 11, UNBOUND_VALUE = 12 };
private:
enum_type enum_value;

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

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

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

void copy_template(const BcmFlagsBitIndex__enum_template& other_value);

public:
BcmFlagsBitIndex__enum_template();
BcmFlagsBitIndex__enum_template(template_sel other_value);
BcmFlagsBitIndex__enum_template(int other_value);
BcmFlagsBitIndex__enum_template(BcmFlagsBitIndex__enum::enum_type other_value);
BcmFlagsBitIndex__enum_template(const BcmFlagsBitIndex__enum& other_value);
BcmFlagsBitIndex__enum_template(const OPTIONAL<BcmFlagsBitIndex__enum>& other_value);
BcmFlagsBitIndex__enum_template(const BcmFlagsBitIndex__enum_template& other_value);
~BcmFlagsBitIndex__enum_template();

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

boolean match(BcmFlagsBitIndex__enum::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const BcmFlagsBitIndex__enum& other_value, boolean legacy = FALSE) const;
BcmFlagsBitIndex__enum::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
BcmFlagsBitIndex__enum_template& list_item(unsigned int list_index);
void log() const;
void log_match(const BcmFlagsBitIndex__enum& 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 BcmFlags__enum : public Base_Type { // enum
friend class BcmFlags__enum_template;
public:
enum enum_type { e__CAN__BCM__SETTIMER = 1, e__CAN__BCM__STARTTIMER = 2, e__CAN__BCM__TX__COUNTEVT = 4, e__CAN__BCM__TX__ANNOUNCE = 8, e__CAN__BCM__TX__CP__CAN__ID = 16, e__CAN__BCM__RX__FILTER__ID = 32, e__CAN__BCM__RX__CHECK__DLC = 64, e__CAN__BCM__RX__NO__AUTOTIMER = 128, e__CAN__BCM__RX__ANNOUNCE__RESUME = 256, e__CAN__BCM__TX__RESET__MULTI__IDX = 512, e__CAN__BCM__RX__RTR__FRAME = 1024, UNKNOWN_VALUE = 0, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

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

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

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

void copy_template(const BcmFlags__enum_template& other_value);

public:
BcmFlags__enum_template();
BcmFlags__enum_template(template_sel other_value);
BcmFlags__enum_template(int other_value);
BcmFlags__enum_template(BcmFlags__enum::enum_type other_value);
BcmFlags__enum_template(const BcmFlags__enum& other_value);
BcmFlags__enum_template(const OPTIONAL<BcmFlags__enum>& other_value);
BcmFlags__enum_template(const BcmFlags__enum_template& other_value);
~BcmFlags__enum_template();

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

boolean match(BcmFlags__enum::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const BcmFlags__enum& other_value, boolean legacy = FALSE) const;
BcmFlags__enum::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
BcmFlags__enum_template& list_item(unsigned int list_index);
void log() const;
void log_match(const BcmFlags__enum& 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 BcmOpcode__enum : public Base_Type { // enum
friend class BcmOpcode__enum_template;
public:
enum enum_type { e__CAN__BCM__TX__SETUP = 1, e__CAN__BCM__TX__DELETE = 2, e__CAN__BCM__TX__READ = 3, e__CAN__BCM__TX__SEND = 4, e__CAN__BCM__RX__SETUP = 5, e__CAN__BCM__RX__DELETE = 6, e__CAN__BCM__RX__READ = 7, e__CAN__BCM__TX__STATUS = 8, e__CAN__BCM__TX__EXPIRED = 9, e__CAN__BCM__RX__STATUS = 10, e__CAN__BCM__RX__TIMEOUT = 11, e__CAN__BCM__RX__CHANGED = 12, UNKNOWN_VALUE = 0, UNBOUND_VALUE = 13 };
private:
enum_type enum_value;

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

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

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

void copy_template(const BcmOpcode__enum_template& other_value);

public:
BcmOpcode__enum_template();
BcmOpcode__enum_template(template_sel other_value);
BcmOpcode__enum_template(int other_value);
BcmOpcode__enum_template(BcmOpcode__enum::enum_type other_value);
BcmOpcode__enum_template(const BcmOpcode__enum& other_value);
BcmOpcode__enum_template(const OPTIONAL<BcmOpcode__enum>& other_value);
BcmOpcode__enum_template(const BcmOpcode__enum_template& other_value);
~BcmOpcode__enum_template();

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

boolean match(BcmOpcode__enum::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const BcmOpcode__enum& other_value, boolean legacy = FALSE) const;
BcmOpcode__enum::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
BcmOpcode__enum_template& list_item(unsigned int list_index);
void log() const;
void log_match(const BcmOpcode__enum& 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 Bcm__timeval {
  INTEGER field_tv__sec;
  INTEGER field_tv__usec;
public:
  Bcm__timeval();
  Bcm__timeval(const INTEGER& par_tv__sec,
    const INTEGER& par_tv__usec);
  Bcm__timeval(const Bcm__timeval& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  Bcm__timeval& operator=(const Bcm__timeval& other_value);
  boolean operator==(const Bcm__timeval& other_value) const;
  inline boolean operator!=(const Bcm__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 Bcm__timeval_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
Bcm__timeval_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const Bcm__timeval& other_value);
void copy_template(const Bcm__timeval_template& other_value);

public:
Bcm__timeval_template();
Bcm__timeval_template(template_sel other_value);
Bcm__timeval_template(const Bcm__timeval& other_value);
Bcm__timeval_template(const OPTIONAL<Bcm__timeval>& other_value);
Bcm__timeval_template(const Bcm__timeval_template& other_value);
~Bcm__timeval_template();
Bcm__timeval_template& operator=(template_sel other_value);
Bcm__timeval_template& operator=(const Bcm__timeval& other_value);
Bcm__timeval_template& operator=(const OPTIONAL<Bcm__timeval>& other_value);
Bcm__timeval_template& operator=(const Bcm__timeval_template& other_value);
boolean match(const Bcm__timeval& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
Bcm__timeval valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
Bcm__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 Bcm__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__bcm__frame_frames : 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 {
SocketCAN__bcm__frame_frames_can__frame *field_can__frame;
SocketCAN__bcm__frame_frames_canfd__frame *field_canfd__frame;
};
void copy_value(const SocketCAN__bcm__frame_frames& other_value);

public:
SocketCAN__bcm__frame_frames();
SocketCAN__bcm__frame_frames(const SocketCAN__bcm__frame_frames& other_value);
~SocketCAN__bcm__frame_frames();
SocketCAN__bcm__frame_frames& operator=(const SocketCAN__bcm__frame_frames& other_value);
boolean operator==(const SocketCAN__bcm__frame_frames& other_value) const;
inline boolean operator!=(const SocketCAN__bcm__frame_frames& other_value) const { return !(*this == other_value); }
SocketCAN__bcm__frame_frames_can__frame& can__frame();
const SocketCAN__bcm__frame_frames_can__frame& can__frame() const;
SocketCAN__bcm__frame_frames_canfd__frame& canfd__frame();
const SocketCAN__bcm__frame_frames_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__bcm__frame_frames_template : public Base_Template {
union {
struct {
SocketCAN__bcm__frame_frames::union_selection_type union_selection;
union {
SocketCAN__bcm__frame_frames_can__frame_template *field_can__frame;
SocketCAN__bcm__frame_frames_canfd__frame_template *field_canfd__frame;
};
} single_value;
struct {
unsigned int n_values;
SocketCAN__bcm__frame_frames_template *list_value;
} value_list;
};
void copy_value(const SocketCAN__bcm__frame_frames& other_value);

void copy_template(const SocketCAN__bcm__frame_frames_template& other_value);

public:
SocketCAN__bcm__frame_frames_template();
SocketCAN__bcm__frame_frames_template(template_sel other_value);
SocketCAN__bcm__frame_frames_template(const SocketCAN__bcm__frame_frames& other_value);
SocketCAN__bcm__frame_frames_template(const OPTIONAL<SocketCAN__bcm__frame_frames>& other_value);
SocketCAN__bcm__frame_frames_template(const SocketCAN__bcm__frame_frames_template& other_value);
~SocketCAN__bcm__frame_frames_template();
void clean_up();
SocketCAN__bcm__frame_frames_template& operator=(template_sel other_value);
SocketCAN__bcm__frame_frames_template& operator=(const SocketCAN__bcm__frame_frames& other_value);
SocketCAN__bcm__frame_frames_template& operator=(const OPTIONAL<SocketCAN__bcm__frame_frames>& other_value);
SocketCAN__bcm__frame_frames_template& operator=(const SocketCAN__bcm__frame_frames_template& other_value);
boolean match(const SocketCAN__bcm__frame_frames& other_value, boolean legacy = FALSE) const;
boolean is_value() const;SocketCAN__bcm__frame_frames valueof() const;
SocketCAN__bcm__frame_frames_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__bcm__frame_frames_can__frame_template& can__frame();
const SocketCAN__bcm__frame_frames_can__frame_template& can__frame() const;
SocketCAN__bcm__frame_frames_canfd__frame_template& canfd__frame();
const SocketCAN__bcm__frame_frames_canfd__frame_template& canfd__frame() const;
boolean ischosen(SocketCAN__bcm__frame_frames::union_selection_type checked_selection) const;
void log() const;
void log_match(const SocketCAN__bcm__frame_frames& 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__bcm__frame_frames_can__frame : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
Can::CAN__frame **value_elements;
} *val_ptr;

static const Can::CAN__frame UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const SocketCAN__bcm__frame_frames_can__frame& other_value);

public:
  typedef Can::CAN__frame of_type;
SocketCAN__bcm__frame_frames_can__frame();
SocketCAN__bcm__frame_frames_can__frame(null_type other_value);
SocketCAN__bcm__frame_frames_can__frame(const SocketCAN__bcm__frame_frames_can__frame& other_value);
~SocketCAN__bcm__frame_frames_can__frame();

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

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

Can::CAN__frame& operator[](int index_value);
Can::CAN__frame& operator[](const INTEGER& index_value);
const Can::CAN__frame& operator[](int index_value) const;
const Can::CAN__frame& operator[](const INTEGER& index_value) const;

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

SocketCAN__bcm__frame_frames_can__frame operator+(const SocketCAN__bcm__frame_frames_can__frame& other_value) const;

SocketCAN__bcm__frame_frames_can__frame substr(int index, int returncount) const;

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

SocketCAN__bcm__frame_frames_can__frame replace(int index, int len, const SocketCAN__bcm__frame_frames_can__frame_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 SocketCAN__bcm__frame_frames_can__frame_template : public Record_Of_Template {
union {
struct {
int n_elements;
Can::CAN__frame_template **value_elements;
} single_value;
struct {
unsigned int n_values;
SocketCAN__bcm__frame_frames_can__frame_template *list_value;
} value_list;
};
void copy_value(const SocketCAN__bcm__frame_frames_can__frame& other_value);
void copy_template(const SocketCAN__bcm__frame_frames_can__frame_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:
SocketCAN__bcm__frame_frames_can__frame_template();
SocketCAN__bcm__frame_frames_can__frame_template(template_sel other_value);
SocketCAN__bcm__frame_frames_can__frame_template(null_type other_value);
SocketCAN__bcm__frame_frames_can__frame_template(const SocketCAN__bcm__frame_frames_can__frame& other_value);
SocketCAN__bcm__frame_frames_can__frame_template(const OPTIONAL<SocketCAN__bcm__frame_frames_can__frame>& other_value);
SocketCAN__bcm__frame_frames_can__frame_template(const SocketCAN__bcm__frame_frames_can__frame_template& other_value);
~SocketCAN__bcm__frame_frames_can__frame_template();

void clean_up();
SocketCAN__bcm__frame_frames_can__frame_template& operator=(template_sel other_value);
SocketCAN__bcm__frame_frames_can__frame_template& operator=(null_type other_value);
SocketCAN__bcm__frame_frames_can__frame_template& operator=(const SocketCAN__bcm__frame_frames_can__frame& other_value);
SocketCAN__bcm__frame_frames_can__frame_template& operator=(const OPTIONAL<SocketCAN__bcm__frame_frames_can__frame>& other_value);
SocketCAN__bcm__frame_frames_can__frame_template& operator=(const SocketCAN__bcm__frame_frames_can__frame_template& other_value);

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

SocketCAN__bcm__frame_frames_can__frame replace(int index, int len, const SocketCAN__bcm__frame_frames_can__frame_template& repl) const;

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

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

class SocketCAN__bcm__frame_frames_canfd__frame : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
Can::CANFD__frame **value_elements;
} *val_ptr;

static const Can::CANFD__frame UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const SocketCAN__bcm__frame_frames_canfd__frame& other_value);

public:
  typedef Can::CANFD__frame of_type;
SocketCAN__bcm__frame_frames_canfd__frame();
SocketCAN__bcm__frame_frames_canfd__frame(null_type other_value);
SocketCAN__bcm__frame_frames_canfd__frame(const SocketCAN__bcm__frame_frames_canfd__frame& other_value);
~SocketCAN__bcm__frame_frames_canfd__frame();

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

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

Can::CANFD__frame& operator[](int index_value);
Can::CANFD__frame& operator[](const INTEGER& index_value);
const Can::CANFD__frame& operator[](int index_value) const;
const Can::CANFD__frame& operator[](const INTEGER& index_value) const;

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

SocketCAN__bcm__frame_frames_canfd__frame operator+(const SocketCAN__bcm__frame_frames_canfd__frame& other_value) const;

SocketCAN__bcm__frame_frames_canfd__frame substr(int index, int returncount) const;

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

SocketCAN__bcm__frame_frames_canfd__frame replace(int index, int len, const SocketCAN__bcm__frame_frames_canfd__frame_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 SocketCAN__bcm__frame_frames_canfd__frame_template : public Record_Of_Template {
union {
struct {
int n_elements;
Can::CANFD__frame_template **value_elements;
} single_value;
struct {
unsigned int n_values;
SocketCAN__bcm__frame_frames_canfd__frame_template *list_value;
} value_list;
};
void copy_value(const SocketCAN__bcm__frame_frames_canfd__frame& other_value);
void copy_template(const SocketCAN__bcm__frame_frames_canfd__frame_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:
SocketCAN__bcm__frame_frames_canfd__frame_template();
SocketCAN__bcm__frame_frames_canfd__frame_template(template_sel other_value);
SocketCAN__bcm__frame_frames_canfd__frame_template(null_type other_value);
SocketCAN__bcm__frame_frames_canfd__frame_template(const SocketCAN__bcm__frame_frames_canfd__frame& other_value);
SocketCAN__bcm__frame_frames_canfd__frame_template(const OPTIONAL<SocketCAN__bcm__frame_frames_canfd__frame>& other_value);
SocketCAN__bcm__frame_frames_canfd__frame_template(const SocketCAN__bcm__frame_frames_canfd__frame_template& other_value);
~SocketCAN__bcm__frame_frames_canfd__frame_template();

void clean_up();
SocketCAN__bcm__frame_frames_canfd__frame_template& operator=(template_sel other_value);
SocketCAN__bcm__frame_frames_canfd__frame_template& operator=(null_type other_value);
SocketCAN__bcm__frame_frames_canfd__frame_template& operator=(const SocketCAN__bcm__frame_frames_canfd__frame& other_value);
SocketCAN__bcm__frame_frames_canfd__frame_template& operator=(const OPTIONAL<SocketCAN__bcm__frame_frames_canfd__frame>& other_value);
SocketCAN__bcm__frame_frames_canfd__frame_template& operator=(const SocketCAN__bcm__frame_frames_canfd__frame_template& other_value);

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

SocketCAN__bcm__frame_frames_canfd__frame replace(int index, int len, const SocketCAN__bcm__frame_frames_canfd__frame_template& repl) const;

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

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

class SocketCAN__bcm__frame {
  OCTETSTRING field_opcode;
  BITSTRING field_flags;
  INTEGER field_count;
  Bcm__timeval field_ival1;
  Bcm__timeval field_ival2;
  OCTETSTRING field_can__id;
  SocketCAN__bcm__frame_frames field_frames;
public:
  SocketCAN__bcm__frame();
  SocketCAN__bcm__frame(const OCTETSTRING& par_opcode,
    const BITSTRING& par_flags,
    const INTEGER& par_count,
    const Bcm__timeval& par_ival1,
    const Bcm__timeval& par_ival2,
    const OCTETSTRING& par_can__id,
    const SocketCAN__bcm__frame_frames& par_frames);
  SocketCAN__bcm__frame(const SocketCAN__bcm__frame& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__bcm__frame& operator=(const SocketCAN__bcm__frame& other_value);
  boolean operator==(const SocketCAN__bcm__frame& other_value) const;
  inline boolean operator!=(const SocketCAN__bcm__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 OCTETSTRING& opcode()
    {return field_opcode;}
  inline const OCTETSTRING& opcode() const
    {return field_opcode;}
  inline BITSTRING& flags()
    {return field_flags;}
  inline const BITSTRING& flags() const
    {return field_flags;}
  inline INTEGER& count()
    {return field_count;}
  inline const INTEGER& count() const
    {return field_count;}
  inline Bcm__timeval& ival1()
    {return field_ival1;}
  inline const Bcm__timeval& ival1() const
    {return field_ival1;}
  inline Bcm__timeval& ival2()
    {return field_ival2;}
  inline const Bcm__timeval& ival2() const
    {return field_ival2;}
  inline OCTETSTRING& can__id()
    {return field_can__id;}
  inline const OCTETSTRING& can__id() const
    {return field_can__id;}
  inline SocketCAN__bcm__frame_frames& frames()
    {return field_frames;}
  inline const SocketCAN__bcm__frame_frames& frames() const
    {return field_frames;}
  inline int size_of() const
    {return 7;}
  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__bcm__frame_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__bcm__frame_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__bcm__frame& other_value);
void copy_template(const SocketCAN__bcm__frame_template& other_value);

public:
SocketCAN__bcm__frame_template();
SocketCAN__bcm__frame_template(template_sel other_value);
SocketCAN__bcm__frame_template(const SocketCAN__bcm__frame& other_value);
SocketCAN__bcm__frame_template(const OPTIONAL<SocketCAN__bcm__frame>& other_value);
SocketCAN__bcm__frame_template(const SocketCAN__bcm__frame_template& other_value);
~SocketCAN__bcm__frame_template();
SocketCAN__bcm__frame_template& operator=(template_sel other_value);
SocketCAN__bcm__frame_template& operator=(const SocketCAN__bcm__frame& other_value);
SocketCAN__bcm__frame_template& operator=(const OPTIONAL<SocketCAN__bcm__frame>& other_value);
SocketCAN__bcm__frame_template& operator=(const SocketCAN__bcm__frame_template& other_value);
boolean match(const SocketCAN__bcm__frame& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__bcm__frame valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__bcm__frame_template& list_item(unsigned int list_index) const;
OCTETSTRING_template& opcode();
const OCTETSTRING_template& opcode() const;
BITSTRING_template& flags();
const BITSTRING_template& flags() const;
INTEGER_template& count();
const INTEGER_template& count() const;
Bcm__timeval_template& ival1();
const Bcm__timeval_template& ival1() const;
Bcm__timeval_template& ival2();
const Bcm__timeval_template& ival2() const;
OCTETSTRING_template& can__id();
const OCTETSTRING_template& can__id() const;
SocketCAN__bcm__frame_frames_template& frames();
const SocketCAN__bcm__frame_frames_template& frames() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__bcm__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;
};


/* Function prototypes */

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

/* Global variable declarations */

extern const INTEGER& CAN__FRAME__MAX__NUMBER;
extern const TTCN_Typedescriptor_t BcmFlagsBitIndex__enum_descr_;
extern const TTCN_Typedescriptor_t BcmFlags__enum_descr_;
extern const TTCN_Typedescriptor_t BcmOpcode__enum_descr_;
extern const XERdescriptor_t Bcm__long_xer_;
extern const TTCN_OERdescriptor_t Bcm__long_oer_;
extern const TTCN_Typedescriptor_t Bcm__long_descr_;
extern const XERdescriptor_t Bcm__timeval_tv__sec_xer_;
extern const TTCN_OERdescriptor_t Bcm__timeval_tv__sec_oer_;
extern const TTCN_Typedescriptor_t Bcm__timeval_tv__sec_descr_;
extern const XERdescriptor_t Bcm__timeval_tv__usec_xer_;
extern const TTCN_OERdescriptor_t Bcm__timeval_tv__usec_oer_;
extern const TTCN_Typedescriptor_t Bcm__timeval_tv__usec_descr_;
extern const TTCN_Typedescriptor_t Bcm__timeval_descr_;
extern const XERdescriptor_t SocketCAN__bcm__frame_opcode_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__bcm__frame_opcode_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__bcm__frame_opcode_descr_;
extern const TTCN_RAWdescriptor_t SocketCAN__bcm__frame_flags_raw_;
extern const XERdescriptor_t SocketCAN__bcm__frame_flags_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__bcm__frame_flags_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__bcm__frame_flags_descr_;
extern const XERdescriptor_t SocketCAN__bcm__frame_count_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__bcm__frame_count_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__bcm__frame_count_descr_;
extern const XERdescriptor_t SocketCAN__bcm__frame_can__id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__bcm__frame_can__id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__bcm__frame_can__id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__bcm__frame_frames_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__bcm__frame_frames_can__frame_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__bcm__frame_frames_canfd__frame_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__bcm__frame_descr_;
extern TTCN_Module module_object;

} /* end of namespace */

#endif