// 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 SocketCANtest_HH
#define SocketCANtest_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 "SocketCAN_PortType.hh"
#include "SocketCAN_Templates.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 SocketCANtest_HH
#endif

namespace SocketCANtest {

/* Forward declarations of classes */

class SocketCAN__open__socket__type;
class SocketCAN__open__socket__type_template;
class e__Phase;
class e__Phase_template;
class SocketCAN__open__raw__result;
class SocketCAN__open__raw__result_template;
class BCM__cmd;
class BCM__cmd_template;
class BCM__cmds;
class BCM__cmds_template;
class SocketCAN__CAN__or__CAN__FD__frames;
class SocketCAN__CAN__or__CAN__FD__frames_template;
class PhaseStartReq;
class PhaseStartReq_template;
class PhaseEndInd;
class PhaseEndInd_template;
class SyncMasterPort;
class SyncSlavePort;
class PTCSet;
class PTCSet_template;

} /* end of namespace */

#ifndef SocketCANtest_HH
#define SocketCANtest_HH

namespace SocketCANtest {

/* Type definitions */

typedef COMPONENT PTC;
typedef COMPONENT_template PTC_template;
typedef COMPONENT MTC;
typedef COMPONENT_template MTC_template;

/* Class definitions */

class SocketCAN__open__socket__type : public Base_Type { // enum
friend class SocketCAN__open__socket__type_template;
public:
enum enum_type { OPEN__CAN__RAW = 0, OPEN__CAN__BCM = 1, OPEN__CAN__ISOTP = 2, UNKNOWN_VALUE = 3, UNBOUND_VALUE = 4 };
private:
enum_type enum_value;

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

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

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

void copy_template(const SocketCAN__open__socket__type_template& other_value);

public:
SocketCAN__open__socket__type_template();
SocketCAN__open__socket__type_template(template_sel other_value);
SocketCAN__open__socket__type_template(int other_value);
SocketCAN__open__socket__type_template(SocketCAN__open__socket__type::enum_type other_value);
SocketCAN__open__socket__type_template(const SocketCAN__open__socket__type& other_value);
SocketCAN__open__socket__type_template(const OPTIONAL<SocketCAN__open__socket__type>& other_value);
SocketCAN__open__socket__type_template(const SocketCAN__open__socket__type_template& other_value);
~SocketCAN__open__socket__type_template();

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

boolean match(SocketCAN__open__socket__type::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const SocketCAN__open__socket__type& other_value, boolean legacy = FALSE) const;
SocketCAN__open__socket__type::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__open__socket__type_template& list_item(unsigned int list_index);
void log() const;
void log_match(const SocketCAN__open__socket__type& 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 e__Phase : public Base_Type { // enum
friend class e__Phase_template;
public:
enum enum_type { e__open__socket = 0, e__testbody1 = 1, e__testbody2 = 2, e__testbody3 = 3, e__testbody4 = 4, e__testbody5 = 5, e__testbody6 = 6, e__testbody7 = 7, e__testbodyEnd = 8, e__close__socket = 9, e__testcase__complete = 10, UNKNOWN_VALUE = 11, UNBOUND_VALUE = 12 };
private:
enum_type enum_value;

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

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

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

void copy_template(const e__Phase_template& other_value);

public:
e__Phase_template();
e__Phase_template(template_sel other_value);
e__Phase_template(int other_value);
e__Phase_template(e__Phase::enum_type other_value);
e__Phase_template(const e__Phase& other_value);
e__Phase_template(const OPTIONAL<e__Phase>& other_value);
e__Phase_template(const e__Phase_template& other_value);
~e__Phase_template();

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

boolean match(e__Phase::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const e__Phase& other_value, boolean legacy = FALSE) const;
e__Phase::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
e__Phase_template& list_item(unsigned int list_index);
void log() const;
void log_match(const e__Phase& 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__open__raw__result {
  SocketCAN__Types::SocketCAN__ifr field_ifr;
  INTEGER field_socket__id;
public:
  SocketCAN__open__raw__result();
  SocketCAN__open__raw__result(const SocketCAN__Types::SocketCAN__ifr& par_ifr,
    const INTEGER& par_socket__id);
  SocketCAN__open__raw__result(const SocketCAN__open__raw__result& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SocketCAN__open__raw__result& operator=(const SocketCAN__open__raw__result& other_value);
  boolean operator==(const SocketCAN__open__raw__result& other_value) const;
  inline boolean operator!=(const SocketCAN__open__raw__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__Types::SocketCAN__ifr& ifr()
    {return field_ifr;}
  inline const SocketCAN__Types::SocketCAN__ifr& ifr() const
    {return field_ifr;}
  inline INTEGER& socket__id()
    {return field_socket__id;}
  inline const INTEGER& socket__id() const
    {return field_socket__id;}
  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__open__raw__result_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
SocketCAN__open__raw__result_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const SocketCAN__open__raw__result& other_value);
void copy_template(const SocketCAN__open__raw__result_template& other_value);

public:
SocketCAN__open__raw__result_template();
SocketCAN__open__raw__result_template(template_sel other_value);
SocketCAN__open__raw__result_template(const SocketCAN__open__raw__result& other_value);
SocketCAN__open__raw__result_template(const OPTIONAL<SocketCAN__open__raw__result>& other_value);
SocketCAN__open__raw__result_template(const SocketCAN__open__raw__result_template& other_value);
~SocketCAN__open__raw__result_template();
SocketCAN__open__raw__result_template& operator=(template_sel other_value);
SocketCAN__open__raw__result_template& operator=(const SocketCAN__open__raw__result& other_value);
SocketCAN__open__raw__result_template& operator=(const OPTIONAL<SocketCAN__open__raw__result>& other_value);
SocketCAN__open__raw__result_template& operator=(const SocketCAN__open__raw__result_template& other_value);
boolean match(const SocketCAN__open__raw__result& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SocketCAN__open__raw__result valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SocketCAN__open__raw__result_template& list_item(unsigned int list_index) const;
SocketCAN__Types::SocketCAN__ifr_template& ifr();
const SocketCAN__Types::SocketCAN__ifr_template& ifr() const;
INTEGER_template& socket__id();
const INTEGER_template& socket__id() const;
int size_of() const;
void log() const;
void log_match(const SocketCAN__open__raw__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 BCM__cmd {
  e__Phase field_phase;
  Bcm::SocketCAN__bcm__frame field_bcm__frame;
public:
  BCM__cmd();
  BCM__cmd(const e__Phase& par_phase,
    const Bcm::SocketCAN__bcm__frame& par_bcm__frame);
  BCM__cmd(const BCM__cmd& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  BCM__cmd& operator=(const BCM__cmd& other_value);
  boolean operator==(const BCM__cmd& other_value) const;
  inline boolean operator!=(const BCM__cmd& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline e__Phase& phase()
    {return field_phase;}
  inline const e__Phase& phase() const
    {return field_phase;}
  inline Bcm::SocketCAN__bcm__frame& bcm__frame()
    {return field_bcm__frame;}
  inline const Bcm::SocketCAN__bcm__frame& bcm__frame() const
    {return field_bcm__frame;}
  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__cmd_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
BCM__cmd_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const BCM__cmd& other_value);
void copy_template(const BCM__cmd_template& other_value);

public:
BCM__cmd_template();
BCM__cmd_template(template_sel other_value);
BCM__cmd_template(const BCM__cmd& other_value);
BCM__cmd_template(const OPTIONAL<BCM__cmd>& other_value);
BCM__cmd_template(const BCM__cmd_template& other_value);
~BCM__cmd_template();
BCM__cmd_template& operator=(template_sel other_value);
BCM__cmd_template& operator=(const BCM__cmd& other_value);
BCM__cmd_template& operator=(const OPTIONAL<BCM__cmd>& other_value);
BCM__cmd_template& operator=(const BCM__cmd_template& other_value);
boolean match(const BCM__cmd& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
BCM__cmd valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
BCM__cmd_template& list_item(unsigned int list_index) const;
e__Phase_template& phase();
const e__Phase_template& phase() const;
Bcm::SocketCAN__bcm__frame_template& bcm__frame();
const Bcm::SocketCAN__bcm__frame_template& bcm__frame() const;
int size_of() const;
void log() const;
void log_match(const BCM__cmd& 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 BCM__cmds : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
BCM__cmd **value_elements;
} *val_ptr;

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

public:
  typedef BCM__cmd of_type;
BCM__cmds();
BCM__cmds(null_type other_value);
BCM__cmds(const BCM__cmds& other_value);
~BCM__cmds();

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

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

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

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

BCM__cmds operator+(const BCM__cmds& other_value) const;

BCM__cmds substr(int index, int returncount) const;

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

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

void clean_up();
BCM__cmds_template& operator=(template_sel other_value);
BCM__cmds_template& operator=(null_type other_value);
BCM__cmds_template& operator=(const BCM__cmds& other_value);
BCM__cmds_template& operator=(const OPTIONAL<BCM__cmds>& other_value);
BCM__cmds_template& operator=(const BCM__cmds_template& other_value);

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

BCM__cmds replace(int index, int len, const BCM__cmds_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
BCM__cmds_template& list_item(unsigned int list_index);
void log() const;
void log_match(const BCM__cmds& 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__CAN__or__CAN__FD__frames : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame **value_elements;
} *val_ptr;

static const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const SocketCAN__CAN__or__CAN__FD__frames& other_value);

public:
  typedef SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame of_type;
SocketCAN__CAN__or__CAN__FD__frames();
SocketCAN__CAN__or__CAN__FD__frames(null_type other_value);
SocketCAN__CAN__or__CAN__FD__frames(const SocketCAN__CAN__or__CAN__FD__frames& other_value);
~SocketCAN__CAN__or__CAN__FD__frames();

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

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

SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame& operator[](int index_value);
SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame& operator[](const INTEGER& index_value);
const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame& operator[](int index_value) const;
const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame& operator[](const INTEGER& index_value) const;

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

SocketCAN__CAN__or__CAN__FD__frames operator+(const SocketCAN__CAN__or__CAN__FD__frames& other_value) const;

SocketCAN__CAN__or__CAN__FD__frames substr(int index, int returncount) const;

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

SocketCAN__CAN__or__CAN__FD__frames replace(int index, int len, const SocketCAN__CAN__or__CAN__FD__frames_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__CAN__or__CAN__FD__frames_template : public Record_Of_Template {
union {
struct {
int n_elements;
SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame_template **value_elements;
} single_value;
struct {
unsigned int n_values;
SocketCAN__CAN__or__CAN__FD__frames_template *list_value;
} value_list;
};
void copy_value(const SocketCAN__CAN__or__CAN__FD__frames& other_value);
void copy_template(const SocketCAN__CAN__or__CAN__FD__frames_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__CAN__or__CAN__FD__frames_template();
SocketCAN__CAN__or__CAN__FD__frames_template(template_sel other_value);
SocketCAN__CAN__or__CAN__FD__frames_template(null_type other_value);
SocketCAN__CAN__or__CAN__FD__frames_template(const SocketCAN__CAN__or__CAN__FD__frames& other_value);
SocketCAN__CAN__or__CAN__FD__frames_template(const OPTIONAL<SocketCAN__CAN__or__CAN__FD__frames>& other_value);
SocketCAN__CAN__or__CAN__FD__frames_template(const SocketCAN__CAN__or__CAN__FD__frames_template& other_value);
~SocketCAN__CAN__or__CAN__FD__frames_template();

void clean_up();
SocketCAN__CAN__or__CAN__FD__frames_template& operator=(template_sel other_value);
SocketCAN__CAN__or__CAN__FD__frames_template& operator=(null_type other_value);
SocketCAN__CAN__or__CAN__FD__frames_template& operator=(const SocketCAN__CAN__or__CAN__FD__frames& other_value);
SocketCAN__CAN__or__CAN__FD__frames_template& operator=(const OPTIONAL<SocketCAN__CAN__or__CAN__FD__frames>& other_value);
SocketCAN__CAN__or__CAN__FD__frames_template& operator=(const SocketCAN__CAN__or__CAN__FD__frames_template& other_value);

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

SocketCAN__CAN__or__CAN__FD__frames replace(int index, int len, const SocketCAN__CAN__or__CAN__FD__frames_template& repl) const;

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

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

class PhaseStartReq {
  e__Phase field_phase;
  INTEGER field_phase__int;
public:
  PhaseStartReq();
  PhaseStartReq(const e__Phase& par_phase,
    const INTEGER& par_phase__int);
  PhaseStartReq(const PhaseStartReq& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PhaseStartReq& operator=(const PhaseStartReq& other_value);
  boolean operator==(const PhaseStartReq& other_value) const;
  inline boolean operator!=(const PhaseStartReq& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline e__Phase& phase()
    {return field_phase;}
  inline const e__Phase& phase() const
    {return field_phase;}
  inline INTEGER& phase__int()
    {return field_phase__int;}
  inline const INTEGER& phase__int() const
    {return field_phase__int;}
  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 PhaseStartReq_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
PhaseStartReq_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const PhaseStartReq& other_value);
void copy_template(const PhaseStartReq_template& other_value);

public:
PhaseStartReq_template();
PhaseStartReq_template(template_sel other_value);
PhaseStartReq_template(const PhaseStartReq& other_value);
PhaseStartReq_template(const OPTIONAL<PhaseStartReq>& other_value);
PhaseStartReq_template(const PhaseStartReq_template& other_value);
~PhaseStartReq_template();
PhaseStartReq_template& operator=(template_sel other_value);
PhaseStartReq_template& operator=(const PhaseStartReq& other_value);
PhaseStartReq_template& operator=(const OPTIONAL<PhaseStartReq>& other_value);
PhaseStartReq_template& operator=(const PhaseStartReq_template& other_value);
boolean match(const PhaseStartReq& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PhaseStartReq valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PhaseStartReq_template& list_item(unsigned int list_index) const;
e__Phase_template& phase();
const e__Phase_template& phase() const;
INTEGER_template& phase__int();
const INTEGER_template& phase__int() const;
int size_of() const;
void log() const;
void log_match(const PhaseStartReq& 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 PhaseEndInd {
  e__Phase field_phase;
  INTEGER field_phase__int;
public:
  PhaseEndInd();
  PhaseEndInd(const e__Phase& par_phase,
    const INTEGER& par_phase__int);
  PhaseEndInd(const PhaseEndInd& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PhaseEndInd& operator=(const PhaseEndInd& other_value);
  boolean operator==(const PhaseEndInd& other_value) const;
  inline boolean operator!=(const PhaseEndInd& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline e__Phase& phase()
    {return field_phase;}
  inline const e__Phase& phase() const
    {return field_phase;}
  inline INTEGER& phase__int()
    {return field_phase__int;}
  inline const INTEGER& phase__int() const
    {return field_phase__int;}
  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 PhaseEndInd_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
PhaseEndInd_template *list_value;
} value_list;
};

void set_specific();
void copy_value(const PhaseEndInd& other_value);
void copy_template(const PhaseEndInd_template& other_value);

public:
PhaseEndInd_template();
PhaseEndInd_template(template_sel other_value);
PhaseEndInd_template(const PhaseEndInd& other_value);
PhaseEndInd_template(const OPTIONAL<PhaseEndInd>& other_value);
PhaseEndInd_template(const PhaseEndInd_template& other_value);
~PhaseEndInd_template();
PhaseEndInd_template& operator=(template_sel other_value);
PhaseEndInd_template& operator=(const PhaseEndInd& other_value);
PhaseEndInd_template& operator=(const OPTIONAL<PhaseEndInd>& other_value);
PhaseEndInd_template& operator=(const PhaseEndInd_template& other_value);
boolean match(const PhaseEndInd& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PhaseEndInd valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PhaseEndInd_template& list_item(unsigned int list_index) const;
e__Phase_template& phase();
const e__Phase_template& phase() const;
INTEGER_template& phase__int();
const INTEGER_template& phase__int() const;
int size_of() const;
void log() const;
void log_match(const PhaseEndInd& 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 SyncMasterPort : public PORT {
enum msg_selection { MESSAGE_0 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
PhaseEndInd *message_0;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
SyncMasterPort(const char *par_port_name = NULL);
~SyncMasterPort();
void send(const PhaseStartReq& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const PhaseStartReq& send_par, FLOAT* timestamp_redirect = NULL);
void send(const PhaseStartReq_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const PhaseStartReq_template& send_par, FLOAT* timestamp_redirect = NULL);
public:
alt_status receive(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const PhaseEndInd_template& value_template, PhaseEndInd *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const PhaseEndInd_template& value_template, PhaseEndInd *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const PhaseEndInd_template& value_template, PhaseEndInd *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const PhaseEndInd& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class SyncSlavePort : public PORT {
enum msg_selection { MESSAGE_0 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
PhaseStartReq *message_0;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
SyncSlavePort(const char *par_port_name = NULL);
~SyncSlavePort();
void send(const PhaseEndInd& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const PhaseEndInd& send_par, FLOAT* timestamp_redirect = NULL);
void send(const PhaseEndInd_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const PhaseEndInd_template& send_par, FLOAT* timestamp_redirect = NULL);
public:
alt_status receive(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const PhaseStartReq_template& value_template, PhaseStartReq *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const PhaseStartReq_template& value_template, PhaseStartReq *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const PhaseStartReq_template& value_template, PhaseStartReq *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const PhaseStartReq& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class PTCSet : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
COMPONENT **value_elements;
} *val_ptr;

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

public:
  typedef COMPONENT of_type;
PTCSet();
PTCSet(null_type other_value);
PTCSet(const PTCSet& other_value);
~PTCSet();

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

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

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

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

PTCSet operator+(const PTCSet& other_value) const;

PTCSet substr(int index, int returncount) const;

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

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

void clean_up();
PTCSet_template& operator=(template_sel other_value);
PTCSet_template& operator=(null_type other_value);
PTCSet_template& operator=(const PTCSet& other_value);
PTCSet_template& operator=(const OPTIONAL<PTCSet>& other_value);
PTCSet_template& operator=(const PTCSet_template& other_value);

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

PTCSet replace(int index, int len, const PTCSet_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
PTCSet_template& list_item(unsigned int list_index);
void log() const;
void log_match(const PTCSet& 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;
};


/* Function prototypes */

extern boolean operator==(null_type null_value, const BCM__cmds& other_value);
inline boolean operator!=(null_type null_value, const BCM__cmds& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const SocketCAN__CAN__or__CAN__FD__frames& other_value);
inline boolean operator!=(null_type null_value, const SocketCAN__CAN__or__CAN__FD__frames& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const PTCSet& other_value);
inline boolean operator!=(null_type null_value, const PTCSet& other_value) { return !(null_value == other_value); }
extern alt_status alt__awaitPhaseStartReq_instance(const e__Phase& p__phase);
extern void alt__awaitPhaseStartReq(const e__Phase& p__phase);
extern Default_Base *activate_alt__awaitPhaseStartReq(const e__Phase& p__phase);
extern void f__startPhase(const e__Phase& p__phase);
extern void start_f__startPhase(const COMPONENT& component_reference, const e__Phase& p__phase);
extern e__Phase f__incPTCPhase(const e__Phase& p__currentPhase);
extern void start_f__incPTCPhase(const COMPONENT& component_reference, const e__Phase& p__currentPhase);
extern void f__sendPhaseEndInd();
extern void start_f__sendPhaseEndInd(const COMPONENT& component_reference);
extern void f__addSyncSlaveSet(const COMPONENT& p__slave, PTCSet& p__set);
extern e__Phase f__incMTCPhase(const e__Phase& p__currentPhase);
extern void start_f__incMTCPhase(const COMPONENT& component_reference, const e__Phase& p__currentPhase);
extern void f__awaitEndPhase(const e__Phase& p__phase);
extern void start_f__awaitEndPhase(const COMPONENT& component_reference, const e__Phase& p__phase);
extern SocketCAN__Types::SocketCAN__socket__result f__open__socket(const SocketCAN__open__socket__type& v__socket__type);
extern void start_f__open__socket(const COMPONENT& component_reference, const SocketCAN__open__socket__type& v__socket__type);
extern SocketCAN__Types::SocketCAN__ioctl__result f__ioctl__get__if__index(const INTEGER& p__socket__id);
extern void start_f__ioctl__get__if__index(const COMPONENT& component_reference, const INTEGER& p__socket__id);
extern SocketCAN__Types::SocketCAN__connect__result f__connect(const INTEGER& p__socket__id, const INTEGER& p__if__index);
extern void start_f__connect(const COMPONENT& component_reference, const INTEGER& p__socket__id, const INTEGER& p__if__index);
extern SocketCAN__Types::SocketCAN__bind__result f__bind(const INTEGER& p__socket__id, const INTEGER& p__if__index);
extern void start_f__bind(const COMPONENT& component_reference, const INTEGER& p__socket__id, const INTEGER& p__if__index);
extern SocketCAN__Types::SocketCAN__send__data__result f__send__data(const INTEGER& p__socket__id, const SocketCAN__Types::SocketCAN__send__data__ifu& p__ifu, const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame& p__CAN__or__CAN__FD__frame);
extern void start_f__send__data(const COMPONENT& component_reference, const INTEGER& p__socket__id, const SocketCAN__Types::SocketCAN__send__data__ifu& p__ifu, const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame& p__CAN__or__CAN__FD__frame);
extern void f__receive__data(const INTEGER& p__socket__id, const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame_template& p__frame__expected);
extern void start_f__receive__data(const COMPONENT& component_reference, const INTEGER& p__socket__id, const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame_template& p__frame__expected);
extern void f__receive__no__data__but__timeout(const INTEGER& p__socket__id, const FLOAT& p__timeout__period);
extern void start_f__receive__no__data__but__timeout(const COMPONENT& component_reference, const INTEGER& p__socket__id, const FLOAT& p__timeout__period);
extern void f__write__data(const INTEGER& p__socket__id, const Bcm::SocketCAN__bcm__frame& p__bcm__frame);
extern void start_f__write__data(const COMPONENT& component_reference, const INTEGER& p__socket__id, const Bcm::SocketCAN__bcm__frame& p__bcm__frame);
extern void f__receive__BCM__message(const INTEGER_template& p__socket__id, const Bcm::SocketCAN__bcm__frame_template& p__BCM__message__expected);
extern void start_f__receive__BCM__message(const COMPONENT& component_reference, const INTEGER_template& p__socket__id, const Bcm::SocketCAN__bcm__frame_template& p__BCM__message__expected);
extern SocketCAN__Types::SocketCAN__setsockopt__result f__setsockopt(const INTEGER& p__socket__id, const SocketCAN__Types::SocketCAN__setsockopt__commandu& p__command);
extern void start_f__setsockopt(const COMPONENT& component_reference, const INTEGER& p__socket__id, const SocketCAN__Types::SocketCAN__setsockopt__commandu& p__command);
extern void f__close__socket(const INTEGER& p__socket__id);
extern void start_f__close__socket(const COMPONENT& component_reference, const INTEGER& p__socket__id);
extern SocketCAN__open__raw__result f__open__raw();
extern void start_f__open__raw(const COMPONENT& component_reference);
extern INTEGER f__open__bcm();
extern void start_f__open__bcm(const COMPONENT& component_reference);
extern void f__ptc__RawSendInitiator(const e__Phase& p__phase, const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame& v__frame__send);
extern void start_f__ptc__RawSendInitiator(const COMPONENT& component_reference, const e__Phase& p__phase, const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame& v__frame__send);
extern void f__ptc__RawFrameReceiver(const e__Phase& p__phase, const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame_template& p__frame__expected);
extern void start_f__ptc__RawFrameReceiver(const COMPONENT& component_reference, const e__Phase& p__phase, const SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame_template& p__frame__expected);
extern void f__ptc__RawFrameSequenceReceiver(const e__Phase& p__sequence__expected__phase, const SocketCAN__CAN__or__CAN__FD__frames_template& p__frame__sequence__expected, const e__Phase& p__no__further__frames__expected__phase, const FLOAT& p__timeout__period);
extern void start_f__ptc__RawFrameSequenceReceiver(const COMPONENT& component_reference, const e__Phase& p__sequence__expected__phase, const SocketCAN__CAN__or__CAN__FD__frames_template& p__frame__sequence__expected, const e__Phase& p__no__further__frames__expected__phase, const FLOAT& p__timeout__period);
extern void f__ptc__bcmComandSendInitiator(const BCM__cmds& p__cmd__list);
extern void start_f__ptc__bcmComandSendInitiator(const COMPONENT& component_reference, const BCM__cmds& p__cmd__list);
extern void f__ptc__bcmComandSendReceiveInitiator(const BCM__cmds& p__cmd__list);
extern void start_f__ptc__bcmComandSendReceiveInitiator(const COMPONENT& component_reference, const BCM__cmds& p__cmd__list);
extern void f__ptc__bcmSendInitiator(const e__Phase& p__phase, const Bcm::SocketCAN__bcm__frame& p__bcm__frame);
extern void start_f__ptc__bcmSendInitiator(const COMPONENT& component_reference, const e__Phase& p__phase, const Bcm::SocketCAN__bcm__frame& p__bcm__frame);
extern void f__raw__setsockopt(const e__Phase& p__phase, const SocketCAN__Types::SocketCAN__setsockopt__commandu& p__setsockopt__command);
extern void start_f__raw__setsockopt(const COMPONENT& component_reference, const e__Phase& p__phase, const SocketCAN__Types::SocketCAN__setsockopt__commandu& p__setsockopt__command);

/* Global variable declarations */

extern const FLOAT& c__guard;
extern const TTCN_Typedescriptor_t SocketCAN__open__socket__type_descr_;
extern const TTCN_Typedescriptor_t e__Phase_descr_;
extern const XERdescriptor_t SocketCAN__open__raw__result_socket__id_xer_;
extern const TTCN_OERdescriptor_t SocketCAN__open__raw__result_socket__id_oer_;
extern const TTCN_Typedescriptor_t SocketCAN__open__raw__result_socket__id_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__open__raw__result_descr_;
extern const TTCN_Typedescriptor_t BCM__cmd_descr_;
extern const TTCN_Typedescriptor_t BCM__cmds_descr_;
extern const TTCN_Typedescriptor_t SocketCAN__CAN__or__CAN__FD__frames_descr_;
extern const e__Phase& c__firstPhase;
extern const e__Phase& c__testcase__complete;
extern const XERdescriptor_t PhaseStartReq_phase__int_xer_;
extern const TTCN_OERdescriptor_t PhaseStartReq_phase__int_oer_;
extern const TTCN_Typedescriptor_t PhaseStartReq_phase__int_descr_;
extern const TTCN_Typedescriptor_t PhaseStartReq_descr_;
extern const XERdescriptor_t PhaseEndInd_phase__int_xer_;
extern const TTCN_OERdescriptor_t PhaseEndInd_phase__int_oer_;
extern const TTCN_Typedescriptor_t PhaseEndInd_phase__int_descr_;
extern const TTCN_Typedescriptor_t PhaseEndInd_descr_;
extern const TTCN_Typedescriptor_t PTCSet_descr_;
extern const TTCN_Typedescriptor_t& PTC_descr_;
extern SyncSlavePort PTC_component_pt__sync;
extern SocketCAN__PortType::SocketCAN__PT PTC_component_pt__socketCAN;
extern e__Phase PTC_component_v__phase;
extern const TTCN_Typedescriptor_t& MTC_descr_;
extern TIMER MTC_component_t__guard;
extern SyncMasterPort MTC_component_pt__sync;
extern PTCSet MTC_component_v__PTCSet;
extern TTCN_Module module_object;

} /* end of namespace */

#endif