demo/UnifiedDiagnosticServices.hh

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

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

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

#ifndef UnifiedDiagnosticServices_HH
#define UnifiedDiagnosticServices_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 "General_Types.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 UnifiedDiagnosticServices_HH
#endif

namespace UnifiedDiagnosticServices {

/* Forward declarations of classes */

class SuppressPosRspMsgIndicationBitType;
class SuppressPosRspMsgIndicationBitType_template;
class DefaultSessionRequest;
class DefaultSessionRequest_template;
class ProgrammingSessionRequest;
class ProgrammingSessionRequest_template;
class ExtendedDiagnosticSessionRequest;
class ExtendedDiagnosticSessionRequest_template;
class SafetySystemDiagnosticSessionRequest;
class SafetySystemDiagnosticSessionRequest_template;
class DiagnosticSessionRequestType;
class DiagnosticSessionRequestType_template;
class DiagnosticSessionControlRequestSID;
class DiagnosticSessionControlRequestSID_template;
class DiagnosticSessionResponseType;
class DiagnosticSessionResponseType_template;
class DefaultSessionResponse;
class DefaultSessionResponse_template;
class ProgrammingSessionResponse;
class ProgrammingSessionResponse_template;
class ExtendedDiagnosticSessionResponse;
class ExtendedDiagnosticSessionResponse_template;
class SafetySystemDiagnosticSessionResponse;
class SafetySystemDiagnosticSessionResponse_template;
class DiagnosticSessionControlResponseSID;
class DiagnosticSessionControlResponseSID_template;
class HardResetRequest;
class HardResetRequest_template;
class KeyOffOnResetRequest;
class KeyOffOnResetRequest_template;
class SoftResetRequest;
class SoftResetRequest_template;
class EnableRapidPowerShutDownRequest;
class EnableRapidPowerShutDownRequest_template;
class DisableRapidPowerShutDownRequest;
class DisableRapidPowerShutDownRequest_template;
class ECUResetRequestType;
class ECUResetRequestType_template;
class HardResetResponse;
class HardResetResponse_template;
class KeyOffOnResetResponse;
class KeyOffOnResetResponse_template;
class SoftResetResponse;
class SoftResetResponse_template;
class EnableRapidPowerShutDownResponse;
class EnableRapidPowerShutDownResponse_template;
class DisableRapidPowerShutDownResponse;
class DisableRapidPowerShutDownResponse_template;
class ECUResetResponseType;
class ECUResetResponseType_template;
class ECUResetRequestSID;
class ECUResetRequestSID_template;
class ECUResetResponseSID;
class ECUResetResponseSID_template;
class RequestSeedRequest0;
class RequestSeedRequest0_template;
class SendKeyRequest0;
class SendKeyRequest0_template;
class RequestSeedRequest1;
class RequestSeedRequest1_template;
class SendKeyRequest1;
class SendKeyRequest1_template;
class SecurityAccessRequestType;
class SecurityAccessRequestType_template;
class SecurityAccessRequestSID;
class SecurityAccessRequestSID_template;
class RequestSeedResponse0;
class RequestSeedResponse0_template;
class SendKeyResponse0;
class SendKeyResponse0_template;
class RequestSeedResponse1;
class RequestSeedResponse1_template;
class SendKeyResponse1;
class SendKeyResponse1_template;
class SecurityAccessResponseType;
class SecurityAccessResponseType_template;
class SecurityAccessResponseSID;
class SecurityAccessResponseSID_template;
class e__ControlType;
class e__ControlType_template;
class e__DisableEnable;
class e__DisableEnable_template;
class e__CommunicationMessages;
class e__CommunicationMessages_template;
class CommunicationType;
class CommunicationType_template;
class EnableRxAndTxRequest;
class EnableRxAndTxRequest_template;
class EnableRxAndDisableTxRequest;
class EnableRxAndDisableTxRequest_template;
class DisableRxAndEnableTxRequest;
class DisableRxAndEnableTxRequest_template;
class DisableRxAndTxRequest;
class DisableRxAndTxRequest_template;
class EnableRxAndDisableTxWithEnhancedAddressInformationRequest;
class EnableRxAndDisableTxWithEnhancedAddressInformationRequest_template;
class EnableRxAndTxWithEnhancedAddressInformationRequest;
class EnableRxAndTxWithEnhancedAddressInformationRequest_template;
class CommunicationControlRequestType;
class CommunicationControlRequestType_template;
class CommunicationControlRequestSID;
class CommunicationControlRequestSID_template;
class CommunicationControlResponseSID;
class CommunicationControlResponseSID_template;
class TesterPresentRequestSID;
class TesterPresentRequestSID_template;
class TesterPresentResponseSID;
class TesterPresentResponseSID_template;
class ReadDataByIdentifierRequest1;
class ReadDataByIdentifierRequest1_template;
class ReadDataByIdentifierRequest2;
class ReadDataByIdentifierRequest2_template;
class ReadDataByIdentifierRequest3;
class ReadDataByIdentifierRequest3_template;
class ReadDataByIdentifierRequest;
class ReadDataByIdentifierRequest_template;
class ReadDataByIdentifierRequestSID;
class ReadDataByIdentifierRequestSID_template;
class ReadDataByIdentifierResponse1;
class ReadDataByIdentifierResponse1_template;
class ReadDataByIdentifierResponse2;
class ReadDataByIdentifierResponse2_template;
class ReadDataByIdentifierResponse3;
class ReadDataByIdentifierResponse3_template;
class ReadDataByIdentifierResponse;
class ReadDataByIdentifierResponse_template;
class ReadDataByIdentifierResponseSID;
class ReadDataByIdentifierResponseSID_template;
class WriteDataByIdentifierRequest1;
class WriteDataByIdentifierRequest1_template;
class WriteDataByIdentifierRequest2;
class WriteDataByIdentifierRequest2_template;
class WriteDataByIdentifierRequest3;
class WriteDataByIdentifierRequest3_template;
class WriteDataByIdentifierRequest;
class WriteDataByIdentifierRequest_template;
class WriteDataByIdentifierRequestSID;
class WriteDataByIdentifierRequestSID_template;
class WriteDataByIdentifierResponse1;
class WriteDataByIdentifierResponse1_template;
class WriteDataByIdentifierResponse2;
class WriteDataByIdentifierResponse2_template;
class WriteDataByIdentifierResponse3;
class WriteDataByIdentifierResponse3_template;
class WriteDataByIdentifierResponse;
class WriteDataByIdentifierResponse_template;
class WriteDataByIdentifierResponseSID;
class WriteDataByIdentifierResponseSID_template;
class e__RequestSID;
class e__RequestSID_template;
class e__ResponseCode;
class e__ResponseCode_template;
class NegativeResponseCodeSID;
class NegativeResponseCodeSID_template;
class TopLevelMessage__UDS__requests;
class TopLevelMessage__UDS__requests_template;
class TopLevelMessage__UDS__responses;
class TopLevelMessage__UDS__responses_template;

} /* end of namespace */

#ifndef UnifiedDiagnosticServices_HH
#define UnifiedDiagnosticServices_HH

namespace UnifiedDiagnosticServices {

/* Type definitions */

typedef OCTETSTRING SID;
typedef OCTETSTRING_template SID_template;
typedef BITSTRING DiagnosticSessionType;
typedef BITSTRING_template DiagnosticSessionType_template;
typedef BITSTRING ResetType;
typedef BITSTRING_template ResetType_template;
typedef OCTETSTRING PowerDownTime;
typedef OCTETSTRING_template PowerDownTime_template;
typedef BITSTRING SecurityAccessType;
typedef BITSTRING_template SecurityAccessType_template;
typedef BITSTRING ControlType;
typedef BITSTRING_template ControlType_template;
typedef OCTETSTRING NodeIdentificationNumber;
typedef OCTETSTRING_template NodeIdentificationNumber_template;
typedef OCTETSTRING ServiceIdentifier;
typedef OCTETSTRING_template ServiceIdentifier_template;

/* Class definitions */

class SuppressPosRspMsgIndicationBitType : public Base_Type { // enum
friend class SuppressPosRspMsgIndicationBitType_template;
public:
enum enum_type { doNotsuppresssPos = 0, suppresssPos = 1, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const SuppressPosRspMsgIndicationBitType& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const SuppressPosRspMsgIndicationBitType& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const SuppressPosRspMsgIndicationBitType& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const SuppressPosRspMsgIndicationBitType& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const SuppressPosRspMsgIndicationBitType& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const SuppressPosRspMsgIndicationBitType& 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 SuppressPosRspMsgIndicationBitType& 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);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class SuppressPosRspMsgIndicationBitType_template : public Base_Template {
union {
SuppressPosRspMsgIndicationBitType::enum_type single_value;
struct {
unsigned int n_values;
SuppressPosRspMsgIndicationBitType_template *list_value;
} value_list;
};

void copy_template(const SuppressPosRspMsgIndicationBitType_template& other_value);

public:
SuppressPosRspMsgIndicationBitType_template();
SuppressPosRspMsgIndicationBitType_template(template_sel other_value);
SuppressPosRspMsgIndicationBitType_template(int other_value);
SuppressPosRspMsgIndicationBitType_template(SuppressPosRspMsgIndicationBitType::enum_type other_value);
SuppressPosRspMsgIndicationBitType_template(const SuppressPosRspMsgIndicationBitType& other_value);
SuppressPosRspMsgIndicationBitType_template(const OPTIONAL<SuppressPosRspMsgIndicationBitType>& other_value);
SuppressPosRspMsgIndicationBitType_template(const SuppressPosRspMsgIndicationBitType_template& other_value);
~SuppressPosRspMsgIndicationBitType_template();

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

boolean match(SuppressPosRspMsgIndicationBitType::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const SuppressPosRspMsgIndicationBitType& other_value, boolean legacy = FALSE) const;
SuppressPosRspMsgIndicationBitType::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SuppressPosRspMsgIndicationBitType_template& list_item(unsigned int list_index);
void log() const;
void log_match(const SuppressPosRspMsgIndicationBitType& 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 DefaultSessionRequest : public Base_Type {
  BITSTRING field_diagnosticSessionType;
public:
  DefaultSessionRequest();
  DefaultSessionRequest(const BITSTRING& par_diagnosticSessionType);
  DefaultSessionRequest(const DefaultSessionRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DefaultSessionRequest& operator=(const DefaultSessionRequest& other_value);
  boolean operator==(const DefaultSessionRequest& other_value) const;
  inline boolean operator!=(const DefaultSessionRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& diagnosticSessionType()
    {return field_diagnosticSessionType;}
  inline const BITSTRING& diagnosticSessionType() const
    {return field_diagnosticSessionType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const DefaultSessionRequest& other_value);
void copy_template(const DefaultSessionRequest_template& other_value);

public:
DefaultSessionRequest_template();
DefaultSessionRequest_template(template_sel other_value);
DefaultSessionRequest_template(const DefaultSessionRequest& other_value);
DefaultSessionRequest_template(const OPTIONAL<DefaultSessionRequest>& other_value);
DefaultSessionRequest_template(const DefaultSessionRequest_template& other_value);
~DefaultSessionRequest_template();
DefaultSessionRequest_template& operator=(template_sel other_value);
DefaultSessionRequest_template& operator=(const DefaultSessionRequest& other_value);
DefaultSessionRequest_template& operator=(const OPTIONAL<DefaultSessionRequest>& other_value);
DefaultSessionRequest_template& operator=(const DefaultSessionRequest_template& other_value);
boolean match(const DefaultSessionRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DefaultSessionRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DefaultSessionRequest_template& list_item(unsigned int list_index) const;
BITSTRING_template& diagnosticSessionType();
const BITSTRING_template& diagnosticSessionType() const;
int size_of() const;
void log() const;
void log_match(const DefaultSessionRequest& 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 ProgrammingSessionRequest : public Base_Type {
  BITSTRING field_diagnosticSessionType;
public:
  ProgrammingSessionRequest();
  ProgrammingSessionRequest(const BITSTRING& par_diagnosticSessionType);
  ProgrammingSessionRequest(const ProgrammingSessionRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  ProgrammingSessionRequest& operator=(const ProgrammingSessionRequest& other_value);
  boolean operator==(const ProgrammingSessionRequest& other_value) const;
  inline boolean operator!=(const ProgrammingSessionRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& diagnosticSessionType()
    {return field_diagnosticSessionType;}
  inline const BITSTRING& diagnosticSessionType() const
    {return field_diagnosticSessionType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const ProgrammingSessionRequest& other_value);
void copy_template(const ProgrammingSessionRequest_template& other_value);

public:
ProgrammingSessionRequest_template();
ProgrammingSessionRequest_template(template_sel other_value);
ProgrammingSessionRequest_template(const ProgrammingSessionRequest& other_value);
ProgrammingSessionRequest_template(const OPTIONAL<ProgrammingSessionRequest>& other_value);
ProgrammingSessionRequest_template(const ProgrammingSessionRequest_template& other_value);
~ProgrammingSessionRequest_template();
ProgrammingSessionRequest_template& operator=(template_sel other_value);
ProgrammingSessionRequest_template& operator=(const ProgrammingSessionRequest& other_value);
ProgrammingSessionRequest_template& operator=(const OPTIONAL<ProgrammingSessionRequest>& other_value);
ProgrammingSessionRequest_template& operator=(const ProgrammingSessionRequest_template& other_value);
boolean match(const ProgrammingSessionRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
ProgrammingSessionRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
ProgrammingSessionRequest_template& list_item(unsigned int list_index) const;
BITSTRING_template& diagnosticSessionType();
const BITSTRING_template& diagnosticSessionType() const;
int size_of() const;
void log() const;
void log_match(const ProgrammingSessionRequest& 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 ExtendedDiagnosticSessionRequest : public Base_Type {
  BITSTRING field_diagnosticSessionType;
public:
  ExtendedDiagnosticSessionRequest();
  ExtendedDiagnosticSessionRequest(const BITSTRING& par_diagnosticSessionType);
  ExtendedDiagnosticSessionRequest(const ExtendedDiagnosticSessionRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  ExtendedDiagnosticSessionRequest& operator=(const ExtendedDiagnosticSessionRequest& other_value);
  boolean operator==(const ExtendedDiagnosticSessionRequest& other_value) const;
  inline boolean operator!=(const ExtendedDiagnosticSessionRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& diagnosticSessionType()
    {return field_diagnosticSessionType;}
  inline const BITSTRING& diagnosticSessionType() const
    {return field_diagnosticSessionType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const ExtendedDiagnosticSessionRequest& other_value);
void copy_template(const ExtendedDiagnosticSessionRequest_template& other_value);

public:
ExtendedDiagnosticSessionRequest_template();
ExtendedDiagnosticSessionRequest_template(template_sel other_value);
ExtendedDiagnosticSessionRequest_template(const ExtendedDiagnosticSessionRequest& other_value);
ExtendedDiagnosticSessionRequest_template(const OPTIONAL<ExtendedDiagnosticSessionRequest>& other_value);
ExtendedDiagnosticSessionRequest_template(const ExtendedDiagnosticSessionRequest_template& other_value);
~ExtendedDiagnosticSessionRequest_template();
ExtendedDiagnosticSessionRequest_template& operator=(template_sel other_value);
ExtendedDiagnosticSessionRequest_template& operator=(const ExtendedDiagnosticSessionRequest& other_value);
ExtendedDiagnosticSessionRequest_template& operator=(const OPTIONAL<ExtendedDiagnosticSessionRequest>& other_value);
ExtendedDiagnosticSessionRequest_template& operator=(const ExtendedDiagnosticSessionRequest_template& other_value);
boolean match(const ExtendedDiagnosticSessionRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
ExtendedDiagnosticSessionRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
ExtendedDiagnosticSessionRequest_template& list_item(unsigned int list_index) const;
BITSTRING_template& diagnosticSessionType();
const BITSTRING_template& diagnosticSessionType() const;
int size_of() const;
void log() const;
void log_match(const ExtendedDiagnosticSessionRequest& 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 SafetySystemDiagnosticSessionRequest : public Base_Type {
  BITSTRING field_diagnosticSessionType;
public:
  SafetySystemDiagnosticSessionRequest();
  SafetySystemDiagnosticSessionRequest(const BITSTRING& par_diagnosticSessionType);
  SafetySystemDiagnosticSessionRequest(const SafetySystemDiagnosticSessionRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SafetySystemDiagnosticSessionRequest& operator=(const SafetySystemDiagnosticSessionRequest& other_value);
  boolean operator==(const SafetySystemDiagnosticSessionRequest& other_value) const;
  inline boolean operator!=(const SafetySystemDiagnosticSessionRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& diagnosticSessionType()
    {return field_diagnosticSessionType;}
  inline const BITSTRING& diagnosticSessionType() const
    {return field_diagnosticSessionType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const SafetySystemDiagnosticSessionRequest& other_value);
void copy_template(const SafetySystemDiagnosticSessionRequest_template& other_value);

public:
SafetySystemDiagnosticSessionRequest_template();
SafetySystemDiagnosticSessionRequest_template(template_sel other_value);
SafetySystemDiagnosticSessionRequest_template(const SafetySystemDiagnosticSessionRequest& other_value);
SafetySystemDiagnosticSessionRequest_template(const OPTIONAL<SafetySystemDiagnosticSessionRequest>& other_value);
SafetySystemDiagnosticSessionRequest_template(const SafetySystemDiagnosticSessionRequest_template& other_value);
~SafetySystemDiagnosticSessionRequest_template();
SafetySystemDiagnosticSessionRequest_template& operator=(template_sel other_value);
SafetySystemDiagnosticSessionRequest_template& operator=(const SafetySystemDiagnosticSessionRequest& other_value);
SafetySystemDiagnosticSessionRequest_template& operator=(const OPTIONAL<SafetySystemDiagnosticSessionRequest>& other_value);
SafetySystemDiagnosticSessionRequest_template& operator=(const SafetySystemDiagnosticSessionRequest_template& other_value);
boolean match(const SafetySystemDiagnosticSessionRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SafetySystemDiagnosticSessionRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SafetySystemDiagnosticSessionRequest_template& list_item(unsigned int list_index) const;
BITSTRING_template& diagnosticSessionType();
const BITSTRING_template& diagnosticSessionType() const;
int size_of() const;
void log() const;
void log_match(const SafetySystemDiagnosticSessionRequest& 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 DiagnosticSessionRequestType : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_defaultSession = 1, ALT_programmingSession = 2, ALT_extendedDiagnosticSession = 3, ALT_safetySystemDiagnosticSession = 4 };
private:
union_selection_type union_selection;
union {
DefaultSessionRequest *field_defaultSession;
ProgrammingSessionRequest *field_programmingSession;
ExtendedDiagnosticSessionRequest *field_extendedDiagnosticSession;
SafetySystemDiagnosticSessionRequest *field_safetySystemDiagnosticSession;
};
void copy_value(const DiagnosticSessionRequestType& other_value);

public:
DiagnosticSessionRequestType();
DiagnosticSessionRequestType(const DiagnosticSessionRequestType& other_value);
~DiagnosticSessionRequestType();
DiagnosticSessionRequestType& operator=(const DiagnosticSessionRequestType& other_value);
boolean operator==(const DiagnosticSessionRequestType& other_value) const;
inline boolean operator!=(const DiagnosticSessionRequestType& other_value) const { return !(*this == other_value); }
DefaultSessionRequest& defaultSession();
const DefaultSessionRequest& defaultSession() const;
ProgrammingSessionRequest& programmingSession();
const ProgrammingSessionRequest& programmingSession() const;
ExtendedDiagnosticSessionRequest& extendedDiagnosticSession();
const ExtendedDiagnosticSessionRequest& extendedDiagnosticSession() const;
SafetySystemDiagnosticSessionRequest& safetySystemDiagnosticSession();
const SafetySystemDiagnosticSessionRequest& safetySystemDiagnosticSession() 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);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class DiagnosticSessionRequestType_template : public Base_Template {
union {
struct {
DiagnosticSessionRequestType::union_selection_type union_selection;
union {
DefaultSessionRequest_template *field_defaultSession;
ProgrammingSessionRequest_template *field_programmingSession;
ExtendedDiagnosticSessionRequest_template *field_extendedDiagnosticSession;
SafetySystemDiagnosticSessionRequest_template *field_safetySystemDiagnosticSession;
};
} single_value;
struct {
unsigned int n_values;
DiagnosticSessionRequestType_template *list_value;
} value_list;
};
void copy_value(const DiagnosticSessionRequestType& other_value);

void copy_template(const DiagnosticSessionRequestType_template& other_value);

public:
DiagnosticSessionRequestType_template();
DiagnosticSessionRequestType_template(template_sel other_value);
DiagnosticSessionRequestType_template(const DiagnosticSessionRequestType& other_value);
DiagnosticSessionRequestType_template(const OPTIONAL<DiagnosticSessionRequestType>& other_value);
DiagnosticSessionRequestType_template(const DiagnosticSessionRequestType_template& other_value);
~DiagnosticSessionRequestType_template();
void clean_up();
DiagnosticSessionRequestType_template& operator=(template_sel other_value);
DiagnosticSessionRequestType_template& operator=(const DiagnosticSessionRequestType& other_value);
DiagnosticSessionRequestType_template& operator=(const OPTIONAL<DiagnosticSessionRequestType>& other_value);
DiagnosticSessionRequestType_template& operator=(const DiagnosticSessionRequestType_template& other_value);
boolean match(const DiagnosticSessionRequestType& other_value, boolean legacy = FALSE) const;
boolean is_value() const;DiagnosticSessionRequestType valueof() const;
DiagnosticSessionRequestType_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
DefaultSessionRequest_template& defaultSession();
const DefaultSessionRequest_template& defaultSession() const;
ProgrammingSessionRequest_template& programmingSession();
const ProgrammingSessionRequest_template& programmingSession() const;
ExtendedDiagnosticSessionRequest_template& extendedDiagnosticSession();
const ExtendedDiagnosticSessionRequest_template& extendedDiagnosticSession() const;
SafetySystemDiagnosticSessionRequest_template& safetySystemDiagnosticSession();
const SafetySystemDiagnosticSessionRequest_template& safetySystemDiagnosticSession() const;
boolean ischosen(DiagnosticSessionRequestType::union_selection_type checked_selection) const;
void log() const;
void log_match(const DiagnosticSessionRequestType& 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 DiagnosticSessionControlRequestSID : public Base_Type {
  OCTETSTRING field_sid;
  SuppressPosRspMsgIndicationBitType field_suppressPosRspMsgIndicationBit;
  DiagnosticSessionRequestType field_diagnosticSessionType;
public:
  DiagnosticSessionControlRequestSID();
  DiagnosticSessionControlRequestSID(const OCTETSTRING& par_sid,
    const SuppressPosRspMsgIndicationBitType& par_suppressPosRspMsgIndicationBit,
    const DiagnosticSessionRequestType& par_diagnosticSessionType);
  DiagnosticSessionControlRequestSID(const DiagnosticSessionControlRequestSID& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DiagnosticSessionControlRequestSID& operator=(const DiagnosticSessionControlRequestSID& other_value);
  boolean operator==(const DiagnosticSessionControlRequestSID& other_value) const;
  inline boolean operator!=(const DiagnosticSessionControlRequestSID& 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& sid()
    {return field_sid;}
  inline const OCTETSTRING& sid() const
    {return field_sid;}
  inline SuppressPosRspMsgIndicationBitType& suppressPosRspMsgIndicationBit()
    {return field_suppressPosRspMsgIndicationBit;}
  inline const SuppressPosRspMsgIndicationBitType& suppressPosRspMsgIndicationBit() const
    {return field_suppressPosRspMsgIndicationBit;}
  inline DiagnosticSessionRequestType& diagnosticSessionType()
    {return field_diagnosticSessionType;}
  inline const DiagnosticSessionRequestType& diagnosticSessionType() const
    {return field_diagnosticSessionType;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const DiagnosticSessionControlRequestSID& other_value);
void copy_template(const DiagnosticSessionControlRequestSID_template& other_value);

public:
DiagnosticSessionControlRequestSID_template();
DiagnosticSessionControlRequestSID_template(template_sel other_value);
DiagnosticSessionControlRequestSID_template(const DiagnosticSessionControlRequestSID& other_value);
DiagnosticSessionControlRequestSID_template(const OPTIONAL<DiagnosticSessionControlRequestSID>& other_value);
DiagnosticSessionControlRequestSID_template(const DiagnosticSessionControlRequestSID_template& other_value);
~DiagnosticSessionControlRequestSID_template();
DiagnosticSessionControlRequestSID_template& operator=(template_sel other_value);
DiagnosticSessionControlRequestSID_template& operator=(const DiagnosticSessionControlRequestSID& other_value);
DiagnosticSessionControlRequestSID_template& operator=(const OPTIONAL<DiagnosticSessionControlRequestSID>& other_value);
DiagnosticSessionControlRequestSID_template& operator=(const DiagnosticSessionControlRequestSID_template& other_value);
boolean match(const DiagnosticSessionControlRequestSID& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DiagnosticSessionControlRequestSID valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DiagnosticSessionControlRequestSID_template& list_item(unsigned int list_index) const;
OCTETSTRING_template& sid();
const OCTETSTRING_template& sid() const;
SuppressPosRspMsgIndicationBitType_template& suppressPosRspMsgIndicationBit();
const SuppressPosRspMsgIndicationBitType_template& suppressPosRspMsgIndicationBit() const;
DiagnosticSessionRequestType_template& diagnosticSessionType();
const DiagnosticSessionRequestType_template& diagnosticSessionType() const;
int size_of() const;
void log() const;
void log_match(const DiagnosticSessionControlRequestSID& 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 DiagnosticSessionResponseType : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_defaultSession = 1, ALT_programmingSession = 2, ALT_extendedDiagnosticSession = 3, ALT_safetySystemDiagnosticSession = 4 };
private:
union_selection_type union_selection;
union {
DefaultSessionResponse *field_defaultSession;
ProgrammingSessionResponse *field_programmingSession;
ExtendedDiagnosticSessionResponse *field_extendedDiagnosticSession;
SafetySystemDiagnosticSessionResponse *field_safetySystemDiagnosticSession;
};
void copy_value(const DiagnosticSessionResponseType& other_value);

public:
DiagnosticSessionResponseType();
DiagnosticSessionResponseType(const DiagnosticSessionResponseType& other_value);
~DiagnosticSessionResponseType();
DiagnosticSessionResponseType& operator=(const DiagnosticSessionResponseType& other_value);
boolean operator==(const DiagnosticSessionResponseType& other_value) const;
inline boolean operator!=(const DiagnosticSessionResponseType& other_value) const { return !(*this == other_value); }
DefaultSessionResponse& defaultSession();
const DefaultSessionResponse& defaultSession() const;
ProgrammingSessionResponse& programmingSession();
const ProgrammingSessionResponse& programmingSession() const;
ExtendedDiagnosticSessionResponse& extendedDiagnosticSession();
const ExtendedDiagnosticSessionResponse& extendedDiagnosticSession() const;
SafetySystemDiagnosticSessionResponse& safetySystemDiagnosticSession();
const SafetySystemDiagnosticSessionResponse& safetySystemDiagnosticSession() 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);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class DiagnosticSessionResponseType_template : public Base_Template {
union {
struct {
DiagnosticSessionResponseType::union_selection_type union_selection;
union {
DefaultSessionResponse_template *field_defaultSession;
ProgrammingSessionResponse_template *field_programmingSession;
ExtendedDiagnosticSessionResponse_template *field_extendedDiagnosticSession;
SafetySystemDiagnosticSessionResponse_template *field_safetySystemDiagnosticSession;
};
} single_value;
struct {
unsigned int n_values;
DiagnosticSessionResponseType_template *list_value;
} value_list;
};
void copy_value(const DiagnosticSessionResponseType& other_value);

void copy_template(const DiagnosticSessionResponseType_template& other_value);

public:
DiagnosticSessionResponseType_template();
DiagnosticSessionResponseType_template(template_sel other_value);
DiagnosticSessionResponseType_template(const DiagnosticSessionResponseType& other_value);
DiagnosticSessionResponseType_template(const OPTIONAL<DiagnosticSessionResponseType>& other_value);
DiagnosticSessionResponseType_template(const DiagnosticSessionResponseType_template& other_value);
~DiagnosticSessionResponseType_template();
void clean_up();
DiagnosticSessionResponseType_template& operator=(template_sel other_value);
DiagnosticSessionResponseType_template& operator=(const DiagnosticSessionResponseType& other_value);
DiagnosticSessionResponseType_template& operator=(const OPTIONAL<DiagnosticSessionResponseType>& other_value);
DiagnosticSessionResponseType_template& operator=(const DiagnosticSessionResponseType_template& other_value);
boolean match(const DiagnosticSessionResponseType& other_value, boolean legacy = FALSE) const;
boolean is_value() const;DiagnosticSessionResponseType valueof() const;
DiagnosticSessionResponseType_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
DefaultSessionResponse_template& defaultSession();
const DefaultSessionResponse_template& defaultSession() const;
ProgrammingSessionResponse_template& programmingSession();
const ProgrammingSessionResponse_template& programmingSession() const;
ExtendedDiagnosticSessionResponse_template& extendedDiagnosticSession();
const ExtendedDiagnosticSessionResponse_template& extendedDiagnosticSession() const;
SafetySystemDiagnosticSessionResponse_template& safetySystemDiagnosticSession();
const SafetySystemDiagnosticSessionResponse_template& safetySystemDiagnosticSession() const;
boolean ischosen(DiagnosticSessionResponseType::union_selection_type checked_selection) const;
void log() const;
void log_match(const DiagnosticSessionResponseType& 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 DefaultSessionResponse : public Base_Type {
  BITSTRING field_diagnosticSessionType;
  OCTETSTRING field_p2ServerMax;
  OCTETSTRING field_p2StarServerMax;
public:
  DefaultSessionResponse();
  DefaultSessionResponse(const BITSTRING& par_diagnosticSessionType,
    const OCTETSTRING& par_p2ServerMax,
    const OCTETSTRING& par_p2StarServerMax);
  DefaultSessionResponse(const DefaultSessionResponse& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DefaultSessionResponse& operator=(const DefaultSessionResponse& other_value);
  boolean operator==(const DefaultSessionResponse& other_value) const;
  inline boolean operator!=(const DefaultSessionResponse& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& diagnosticSessionType()
    {return field_diagnosticSessionType;}
  inline const BITSTRING& diagnosticSessionType() const
    {return field_diagnosticSessionType;}
  inline OCTETSTRING& p2ServerMax()
    {return field_p2ServerMax;}
  inline const OCTETSTRING& p2ServerMax() const
    {return field_p2ServerMax;}
  inline OCTETSTRING& p2StarServerMax()
    {return field_p2StarServerMax;}
  inline const OCTETSTRING& p2StarServerMax() const
    {return field_p2StarServerMax;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const DefaultSessionResponse& other_value);
void copy_template(const DefaultSessionResponse_template& other_value);

public:
DefaultSessionResponse_template();
DefaultSessionResponse_template(template_sel other_value);
DefaultSessionResponse_template(const DefaultSessionResponse& other_value);
DefaultSessionResponse_template(const OPTIONAL<DefaultSessionResponse>& other_value);
DefaultSessionResponse_template(const DefaultSessionResponse_template& other_value);
~DefaultSessionResponse_template();
DefaultSessionResponse_template& operator=(template_sel other_value);
DefaultSessionResponse_template& operator=(const DefaultSessionResponse& other_value);
DefaultSessionResponse_template& operator=(const OPTIONAL<DefaultSessionResponse>& other_value);
DefaultSessionResponse_template& operator=(const DefaultSessionResponse_template& other_value);
boolean match(const DefaultSessionResponse& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DefaultSessionResponse valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DefaultSessionResponse_template& list_item(unsigned int list_index) const;
BITSTRING_template& diagnosticSessionType();
const BITSTRING_template& diagnosticSessionType() const;
OCTETSTRING_template& p2ServerMax();
const OCTETSTRING_template& p2ServerMax() const;
OCTETSTRING_template& p2StarServerMax();
const OCTETSTRING_template& p2StarServerMax() const;
int size_of() const;
void log() const;
void log_match(const DefaultSessionResponse& 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 ProgrammingSessionResponse : public Base_Type {
  BITSTRING field_diagnosticSessionType;
  OCTETSTRING field_p2ServerMax;
  OCTETSTRING field_p2StarServerMax;
public:
  ProgrammingSessionResponse();
  ProgrammingSessionResponse(const BITSTRING& par_diagnosticSessionType,
    const OCTETSTRING& par_p2ServerMax,
    const OCTETSTRING& par_p2StarServerMax);
  ProgrammingSessionResponse(const ProgrammingSessionResponse& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  ProgrammingSessionResponse& operator=(const ProgrammingSessionResponse& other_value);
  boolean operator==(const ProgrammingSessionResponse& other_value) const;
  inline boolean operator!=(const ProgrammingSessionResponse& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& diagnosticSessionType()
    {return field_diagnosticSessionType;}
  inline const BITSTRING& diagnosticSessionType() const
    {return field_diagnosticSessionType;}
  inline OCTETSTRING& p2ServerMax()
    {return field_p2ServerMax;}
  inline const OCTETSTRING& p2ServerMax() const
    {return field_p2ServerMax;}
  inline OCTETSTRING& p2StarServerMax()
    {return field_p2StarServerMax;}
  inline const OCTETSTRING& p2StarServerMax() const
    {return field_p2StarServerMax;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const ProgrammingSessionResponse& other_value);
void copy_template(const ProgrammingSessionResponse_template& other_value);

public:
ProgrammingSessionResponse_template();
ProgrammingSessionResponse_template(template_sel other_value);
ProgrammingSessionResponse_template(const ProgrammingSessionResponse& other_value);
ProgrammingSessionResponse_template(const OPTIONAL<ProgrammingSessionResponse>& other_value);
ProgrammingSessionResponse_template(const ProgrammingSessionResponse_template& other_value);
~ProgrammingSessionResponse_template();
ProgrammingSessionResponse_template& operator=(template_sel other_value);
ProgrammingSessionResponse_template& operator=(const ProgrammingSessionResponse& other_value);
ProgrammingSessionResponse_template& operator=(const OPTIONAL<ProgrammingSessionResponse>& other_value);
ProgrammingSessionResponse_template& operator=(const ProgrammingSessionResponse_template& other_value);
boolean match(const ProgrammingSessionResponse& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
ProgrammingSessionResponse valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
ProgrammingSessionResponse_template& list_item(unsigned int list_index) const;
BITSTRING_template& diagnosticSessionType();
const BITSTRING_template& diagnosticSessionType() const;
OCTETSTRING_template& p2ServerMax();
const OCTETSTRING_template& p2ServerMax() const;
OCTETSTRING_template& p2StarServerMax();
const OCTETSTRING_template& p2StarServerMax() const;
int size_of() const;
void log() const;
void log_match(const ProgrammingSessionResponse& 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 ExtendedDiagnosticSessionResponse : public Base_Type {
  BITSTRING field_diagnosticSessionType;
  OCTETSTRING field_p2ServerMax;
  OCTETSTRING field_p2StarServerMax;
public:
  ExtendedDiagnosticSessionResponse();
  ExtendedDiagnosticSessionResponse(const BITSTRING& par_diagnosticSessionType,
    const OCTETSTRING& par_p2ServerMax,
    const OCTETSTRING& par_p2StarServerMax);
  ExtendedDiagnosticSessionResponse(const ExtendedDiagnosticSessionResponse& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  ExtendedDiagnosticSessionResponse& operator=(const ExtendedDiagnosticSessionResponse& other_value);
  boolean operator==(const ExtendedDiagnosticSessionResponse& other_value) const;
  inline boolean operator!=(const ExtendedDiagnosticSessionResponse& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& diagnosticSessionType()
    {return field_diagnosticSessionType;}
  inline const BITSTRING& diagnosticSessionType() const
    {return field_diagnosticSessionType;}
  inline OCTETSTRING& p2ServerMax()
    {return field_p2ServerMax;}
  inline const OCTETSTRING& p2ServerMax() const
    {return field_p2ServerMax;}
  inline OCTETSTRING& p2StarServerMax()
    {return field_p2StarServerMax;}
  inline const OCTETSTRING& p2StarServerMax() const
    {return field_p2StarServerMax;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const ExtendedDiagnosticSessionResponse& other_value);
void copy_template(const ExtendedDiagnosticSessionResponse_template& other_value);

public:
ExtendedDiagnosticSessionResponse_template();
ExtendedDiagnosticSessionResponse_template(template_sel other_value);
ExtendedDiagnosticSessionResponse_template(const ExtendedDiagnosticSessionResponse& other_value);
ExtendedDiagnosticSessionResponse_template(const OPTIONAL<ExtendedDiagnosticSessionResponse>& other_value);
ExtendedDiagnosticSessionResponse_template(const ExtendedDiagnosticSessionResponse_template& other_value);
~ExtendedDiagnosticSessionResponse_template();
ExtendedDiagnosticSessionResponse_template& operator=(template_sel other_value);
ExtendedDiagnosticSessionResponse_template& operator=(const ExtendedDiagnosticSessionResponse& other_value);
ExtendedDiagnosticSessionResponse_template& operator=(const OPTIONAL<ExtendedDiagnosticSessionResponse>& other_value);
ExtendedDiagnosticSessionResponse_template& operator=(const ExtendedDiagnosticSessionResponse_template& other_value);
boolean match(const ExtendedDiagnosticSessionResponse& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
ExtendedDiagnosticSessionResponse valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
ExtendedDiagnosticSessionResponse_template& list_item(unsigned int list_index) const;
BITSTRING_template& diagnosticSessionType();
const BITSTRING_template& diagnosticSessionType() const;
OCTETSTRING_template& p2ServerMax();
const OCTETSTRING_template& p2ServerMax() const;
OCTETSTRING_template& p2StarServerMax();
const OCTETSTRING_template& p2StarServerMax() const;
int size_of() const;
void log() const;
void log_match(const ExtendedDiagnosticSessionResponse& 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 SafetySystemDiagnosticSessionResponse : public Base_Type {
  BITSTRING field_diagnosticSessionType;
  OCTETSTRING field_p2ServerMax;
  OCTETSTRING field_p2StarServerMax;
public:
  SafetySystemDiagnosticSessionResponse();
  SafetySystemDiagnosticSessionResponse(const BITSTRING& par_diagnosticSessionType,
    const OCTETSTRING& par_p2ServerMax,
    const OCTETSTRING& par_p2StarServerMax);
  SafetySystemDiagnosticSessionResponse(const SafetySystemDiagnosticSessionResponse& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SafetySystemDiagnosticSessionResponse& operator=(const SafetySystemDiagnosticSessionResponse& other_value);
  boolean operator==(const SafetySystemDiagnosticSessionResponse& other_value) const;
  inline boolean operator!=(const SafetySystemDiagnosticSessionResponse& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& diagnosticSessionType()
    {return field_diagnosticSessionType;}
  inline const BITSTRING& diagnosticSessionType() const
    {return field_diagnosticSessionType;}
  inline OCTETSTRING& p2ServerMax()
    {return field_p2ServerMax;}
  inline const OCTETSTRING& p2ServerMax() const
    {return field_p2ServerMax;}
  inline OCTETSTRING& p2StarServerMax()
    {return field_p2StarServerMax;}
  inline const OCTETSTRING& p2StarServerMax() const
    {return field_p2StarServerMax;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const SafetySystemDiagnosticSessionResponse& other_value);
void copy_template(const SafetySystemDiagnosticSessionResponse_template& other_value);

public:
SafetySystemDiagnosticSessionResponse_template();
SafetySystemDiagnosticSessionResponse_template(template_sel other_value);
SafetySystemDiagnosticSessionResponse_template(const SafetySystemDiagnosticSessionResponse& other_value);
SafetySystemDiagnosticSessionResponse_template(const OPTIONAL<SafetySystemDiagnosticSessionResponse>& other_value);
SafetySystemDiagnosticSessionResponse_template(const SafetySystemDiagnosticSessionResponse_template& other_value);
~SafetySystemDiagnosticSessionResponse_template();
SafetySystemDiagnosticSessionResponse_template& operator=(template_sel other_value);
SafetySystemDiagnosticSessionResponse_template& operator=(const SafetySystemDiagnosticSessionResponse& other_value);
SafetySystemDiagnosticSessionResponse_template& operator=(const OPTIONAL<SafetySystemDiagnosticSessionResponse>& other_value);
SafetySystemDiagnosticSessionResponse_template& operator=(const SafetySystemDiagnosticSessionResponse_template& other_value);
boolean match(const SafetySystemDiagnosticSessionResponse& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SafetySystemDiagnosticSessionResponse valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SafetySystemDiagnosticSessionResponse_template& list_item(unsigned int list_index) const;
BITSTRING_template& diagnosticSessionType();
const BITSTRING_template& diagnosticSessionType() const;
OCTETSTRING_template& p2ServerMax();
const OCTETSTRING_template& p2ServerMax() const;
OCTETSTRING_template& p2StarServerMax();
const OCTETSTRING_template& p2StarServerMax() const;
int size_of() const;
void log() const;
void log_match(const SafetySystemDiagnosticSessionResponse& 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 DiagnosticSessionControlResponseSID : public Base_Type {
  OCTETSTRING field_sid;
  BITSTRING field_reserved;
  DiagnosticSessionResponseType field_diagnosticSessionType;
public:
  DiagnosticSessionControlResponseSID();
  DiagnosticSessionControlResponseSID(const OCTETSTRING& par_sid,
    const BITSTRING& par_reserved,
    const DiagnosticSessionResponseType& par_diagnosticSessionType);
  DiagnosticSessionControlResponseSID(const DiagnosticSessionControlResponseSID& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DiagnosticSessionControlResponseSID& operator=(const DiagnosticSessionControlResponseSID& other_value);
  boolean operator==(const DiagnosticSessionControlResponseSID& other_value) const;
  inline boolean operator!=(const DiagnosticSessionControlResponseSID& 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& sid()
    {return field_sid;}
  inline const OCTETSTRING& sid() const
    {return field_sid;}
  inline BITSTRING& reserved()
    {return field_reserved;}
  inline const BITSTRING& reserved() const
    {return field_reserved;}
  inline DiagnosticSessionResponseType& diagnosticSessionType()
    {return field_diagnosticSessionType;}
  inline const DiagnosticSessionResponseType& diagnosticSessionType() const
    {return field_diagnosticSessionType;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const DiagnosticSessionControlResponseSID& other_value);
void copy_template(const DiagnosticSessionControlResponseSID_template& other_value);

public:
DiagnosticSessionControlResponseSID_template();
DiagnosticSessionControlResponseSID_template(template_sel other_value);
DiagnosticSessionControlResponseSID_template(const DiagnosticSessionControlResponseSID& other_value);
DiagnosticSessionControlResponseSID_template(const OPTIONAL<DiagnosticSessionControlResponseSID>& other_value);
DiagnosticSessionControlResponseSID_template(const DiagnosticSessionControlResponseSID_template& other_value);
~DiagnosticSessionControlResponseSID_template();
DiagnosticSessionControlResponseSID_template& operator=(template_sel other_value);
DiagnosticSessionControlResponseSID_template& operator=(const DiagnosticSessionControlResponseSID& other_value);
DiagnosticSessionControlResponseSID_template& operator=(const OPTIONAL<DiagnosticSessionControlResponseSID>& other_value);
DiagnosticSessionControlResponseSID_template& operator=(const DiagnosticSessionControlResponseSID_template& other_value);
boolean match(const DiagnosticSessionControlResponseSID& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DiagnosticSessionControlResponseSID valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DiagnosticSessionControlResponseSID_template& list_item(unsigned int list_index) const;
OCTETSTRING_template& sid();
const OCTETSTRING_template& sid() const;
BITSTRING_template& reserved();
const BITSTRING_template& reserved() const;
DiagnosticSessionResponseType_template& diagnosticSessionType();
const DiagnosticSessionResponseType_template& diagnosticSessionType() const;
int size_of() const;
void log() const;
void log_match(const DiagnosticSessionControlResponseSID& 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 HardResetRequest : public Base_Type {
  BITSTRING field_resetType;
public:
  HardResetRequest();
  HardResetRequest(const BITSTRING& par_resetType);
  HardResetRequest(const HardResetRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  HardResetRequest& operator=(const HardResetRequest& other_value);
  boolean operator==(const HardResetRequest& other_value) const;
  inline boolean operator!=(const HardResetRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& resetType()
    {return field_resetType;}
  inline const BITSTRING& resetType() const
    {return field_resetType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const HardResetRequest& other_value);
void copy_template(const HardResetRequest_template& other_value);

public:
HardResetRequest_template();
HardResetRequest_template(template_sel other_value);
HardResetRequest_template(const HardResetRequest& other_value);
HardResetRequest_template(const OPTIONAL<HardResetRequest>& other_value);
HardResetRequest_template(const HardResetRequest_template& other_value);
~HardResetRequest_template();
HardResetRequest_template& operator=(template_sel other_value);
HardResetRequest_template& operator=(const HardResetRequest& other_value);
HardResetRequest_template& operator=(const OPTIONAL<HardResetRequest>& other_value);
HardResetRequest_template& operator=(const HardResetRequest_template& other_value);
boolean match(const HardResetRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
HardResetRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
HardResetRequest_template& list_item(unsigned int list_index) const;
BITSTRING_template& resetType();
const BITSTRING_template& resetType() const;
int size_of() const;
void log() const;
void log_match(const HardResetRequest& 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 KeyOffOnResetRequest : public Base_Type {
  BITSTRING field_resetType;
public:
  KeyOffOnResetRequest();
  KeyOffOnResetRequest(const BITSTRING& par_resetType);
  KeyOffOnResetRequest(const KeyOffOnResetRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  KeyOffOnResetRequest& operator=(const KeyOffOnResetRequest& other_value);
  boolean operator==(const KeyOffOnResetRequest& other_value) const;
  inline boolean operator!=(const KeyOffOnResetRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& resetType()
    {return field_resetType;}
  inline const BITSTRING& resetType() const
    {return field_resetType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const KeyOffOnResetRequest& other_value);
void copy_template(const KeyOffOnResetRequest_template& other_value);

public:
KeyOffOnResetRequest_template();
KeyOffOnResetRequest_template(template_sel other_value);
KeyOffOnResetRequest_template(const KeyOffOnResetRequest& other_value);
KeyOffOnResetRequest_template(const OPTIONAL<KeyOffOnResetRequest>& other_value);
KeyOffOnResetRequest_template(const KeyOffOnResetRequest_template& other_value);
~KeyOffOnResetRequest_template();
KeyOffOnResetRequest_template& operator=(template_sel other_value);
KeyOffOnResetRequest_template& operator=(const KeyOffOnResetRequest& other_value);
KeyOffOnResetRequest_template& operator=(const OPTIONAL<KeyOffOnResetRequest>& other_value);
KeyOffOnResetRequest_template& operator=(const KeyOffOnResetRequest_template& other_value);
boolean match(const KeyOffOnResetRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
KeyOffOnResetRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
KeyOffOnResetRequest_template& list_item(unsigned int list_index) const;
BITSTRING_template& resetType();
const BITSTRING_template& resetType() const;
int size_of() const;
void log() const;
void log_match(const KeyOffOnResetRequest& 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 SoftResetRequest : public Base_Type {
  BITSTRING field_resetType;
public:
  SoftResetRequest();
  SoftResetRequest(const BITSTRING& par_resetType);
  SoftResetRequest(const SoftResetRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SoftResetRequest& operator=(const SoftResetRequest& other_value);
  boolean operator==(const SoftResetRequest& other_value) const;
  inline boolean operator!=(const SoftResetRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& resetType()
    {return field_resetType;}
  inline const BITSTRING& resetType() const
    {return field_resetType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const SoftResetRequest& other_value);
void copy_template(const SoftResetRequest_template& other_value);

public:
SoftResetRequest_template();
SoftResetRequest_template(template_sel other_value);
SoftResetRequest_template(const SoftResetRequest& other_value);
SoftResetRequest_template(const OPTIONAL<SoftResetRequest>& other_value);
SoftResetRequest_template(const SoftResetRequest_template& other_value);
~SoftResetRequest_template();
SoftResetRequest_template& operator=(template_sel other_value);
SoftResetRequest_template& operator=(const SoftResetRequest& other_value);
SoftResetRequest_template& operator=(const OPTIONAL<SoftResetRequest>& other_value);
SoftResetRequest_template& operator=(const SoftResetRequest_template& other_value);
boolean match(const SoftResetRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SoftResetRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SoftResetRequest_template& list_item(unsigned int list_index) const;
BITSTRING_template& resetType();
const BITSTRING_template& resetType() const;
int size_of() const;
void log() const;
void log_match(const SoftResetRequest& 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 EnableRapidPowerShutDownRequest : public Base_Type {
  BITSTRING field_resetType;
public:
  EnableRapidPowerShutDownRequest();
  EnableRapidPowerShutDownRequest(const BITSTRING& par_resetType);
  EnableRapidPowerShutDownRequest(const EnableRapidPowerShutDownRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  EnableRapidPowerShutDownRequest& operator=(const EnableRapidPowerShutDownRequest& other_value);
  boolean operator==(const EnableRapidPowerShutDownRequest& other_value) const;
  inline boolean operator!=(const EnableRapidPowerShutDownRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& resetType()
    {return field_resetType;}
  inline const BITSTRING& resetType() const
    {return field_resetType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const EnableRapidPowerShutDownRequest& other_value);
void copy_template(const EnableRapidPowerShutDownRequest_template& other_value);

public:
EnableRapidPowerShutDownRequest_template();
EnableRapidPowerShutDownRequest_template(template_sel other_value);
EnableRapidPowerShutDownRequest_template(const EnableRapidPowerShutDownRequest& other_value);
EnableRapidPowerShutDownRequest_template(const OPTIONAL<EnableRapidPowerShutDownRequest>& other_value);
EnableRapidPowerShutDownRequest_template(const EnableRapidPowerShutDownRequest_template& other_value);
~EnableRapidPowerShutDownRequest_template();
EnableRapidPowerShutDownRequest_template& operator=(template_sel other_value);
EnableRapidPowerShutDownRequest_template& operator=(const EnableRapidPowerShutDownRequest& other_value);
EnableRapidPowerShutDownRequest_template& operator=(const OPTIONAL<EnableRapidPowerShutDownRequest>& other_value);
EnableRapidPowerShutDownRequest_template& operator=(const EnableRapidPowerShutDownRequest_template& other_value);
boolean match(const EnableRapidPowerShutDownRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
EnableRapidPowerShutDownRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
EnableRapidPowerShutDownRequest_template& list_item(unsigned int list_index) const;
BITSTRING_template& resetType();
const BITSTRING_template& resetType() const;
int size_of() const;
void log() const;
void log_match(const EnableRapidPowerShutDownRequest& 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 DisableRapidPowerShutDownRequest : public Base_Type {
  BITSTRING field_resetType;
public:
  DisableRapidPowerShutDownRequest();
  DisableRapidPowerShutDownRequest(const BITSTRING& par_resetType);
  DisableRapidPowerShutDownRequest(const DisableRapidPowerShutDownRequest& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DisableRapidPowerShutDownRequest& operator=(const DisableRapidPowerShutDownRequest& other_value);
  boolean operator==(const DisableRapidPowerShutDownRequest& other_value) const;
  inline boolean operator!=(const DisableRapidPowerShutDownRequest& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& resetType()
    {return field_resetType;}
  inline const BITSTRING& resetType() const
    {return field_resetType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const DisableRapidPowerShutDownRequest& other_value);
void copy_template(const DisableRapidPowerShutDownRequest_template& other_value);

public:
DisableRapidPowerShutDownRequest_template();
DisableRapidPowerShutDownRequest_template(template_sel other_value);
DisableRapidPowerShutDownRequest_template(const DisableRapidPowerShutDownRequest& other_value);
DisableRapidPowerShutDownRequest_template(const OPTIONAL<DisableRapidPowerShutDownRequest>& other_value);
DisableRapidPowerShutDownRequest_template(const DisableRapidPowerShutDownRequest_template& other_value);
~DisableRapidPowerShutDownRequest_template();
DisableRapidPowerShutDownRequest_template& operator=(template_sel other_value);
DisableRapidPowerShutDownRequest_template& operator=(const DisableRapidPowerShutDownRequest& other_value);
DisableRapidPowerShutDownRequest_template& operator=(const OPTIONAL<DisableRapidPowerShutDownRequest>& other_value);
DisableRapidPowerShutDownRequest_template& operator=(const DisableRapidPowerShutDownRequest_template& other_value);
boolean match(const DisableRapidPowerShutDownRequest& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DisableRapidPowerShutDownRequest valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DisableRapidPowerShutDownRequest_template& list_item(unsigned int list_index) const;
BITSTRING_template& resetType();
const BITSTRING_template& resetType() const;
int size_of() const;
void log() const;
void log_match(const DisableRapidPowerShutDownRequest& 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 ECUResetRequestType : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_hardReset = 1, ALT_keyOffOnReset = 2, ALT_softReset = 3, ALT_enableRapidPowerShutDown = 4, ALT_disableRapidPowerShutDown = 5 };
private:
union_selection_type union_selection;
union {
HardResetRequest *field_hardReset;
KeyOffOnResetRequest *field_keyOffOnReset;
SoftResetRequest *field_softReset;
EnableRapidPowerShutDownRequest *field_enableRapidPowerShutDown;
DisableRapidPowerShutDownRequest *field_disableRapidPowerShutDown;
};
void copy_value(const ECUResetRequestType& other_value);

public:
ECUResetRequestType();
ECUResetRequestType(const ECUResetRequestType& other_value);
~ECUResetRequestType();
ECUResetRequestType& operator=(const ECUResetRequestType& other_value);
boolean operator==(const ECUResetRequestType& other_value) const;
inline boolean operator!=(const ECUResetRequestType& other_value) const { return !(*this == other_value); }
HardResetRequest& hardReset();
const HardResetRequest& hardReset() const;
KeyOffOnResetRequest& keyOffOnReset();
const KeyOffOnResetRequest& keyOffOnReset() const;
SoftResetRequest& softReset();
const SoftResetRequest& softReset() const;
EnableRapidPowerShutDownRequest& enableRapidPowerShutDown();
const EnableRapidPowerShutDownRequest& enableRapidPowerShutDown() const;
DisableRapidPowerShutDownRequest& disableRapidPowerShutDown();
const DisableRapidPowerShutDownRequest& disableRapidPowerShutDown() 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);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class ECUResetRequestType_template : public Base_Template {
union {
struct {
ECUResetRequestType::union_selection_type union_selection;
union {
HardResetRequest_template *field_hardReset;
KeyOffOnResetRequest_template *field_keyOffOnReset;
SoftResetRequest_template *field_softReset;
EnableRapidPowerShutDownRequest_template *field_enableRapidPowerShutDown;
DisableRapidPowerShutDownRequest_template *field_disableRapidPowerShutDown;
};
} single_value;
struct {
unsigned int n_values;
ECUResetRequestType_template *list_value;
} value_list;
};
void copy_value(const ECUResetRequestType& other_value);

void copy_template(const ECUResetRequestType_template& other_value);

public:
ECUResetRequestType_template();
ECUResetRequestType_template(template_sel other_value);
ECUResetRequestType_template(const ECUResetRequestType& other_value);
ECUResetRequestType_template(const OPTIONAL<ECUResetRequestType>& other_value);
ECUResetRequestType_template(const ECUResetRequestType_template& other_value);
~ECUResetRequestType_template();
void clean_up();
ECUResetRequestType_template& operator=(template_sel other_value);
ECUResetRequestType_template& operator=(const ECUResetRequestType& other_value);
ECUResetRequestType_template& operator=(const OPTIONAL<ECUResetRequestType>& other_value);
ECUResetRequestType_template& operator=(const ECUResetRequestType_template& other_value);
boolean match(const ECUResetRequestType& other_value, boolean legacy = FALSE) const;
boolean is_value() const;ECUResetRequestType valueof() const;
ECUResetRequestType_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
HardResetRequest_template& hardReset();
const HardResetRequest_template& hardReset() const;
KeyOffOnResetRequest_template& keyOffOnReset();
const KeyOffOnResetRequest_template& keyOffOnReset() const;
SoftResetRequest_template& softReset();
const SoftResetRequest_template& softReset() const;
EnableRapidPowerShutDownRequest_template& enableRapidPowerShutDown();
const EnableRapidPowerShutDownRequest_template& enableRapidPowerShutDown() const;
DisableRapidPowerShutDownRequest_template& disableRapidPowerShutDown();
const DisableRapidPowerShutDownRequest_template& disableRapidPowerShutDown() const;
boolean ischosen(ECUResetRequestType::union_selection_type checked_selection) const;
void log() const;
void log_match(const ECUResetRequestType& 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 HardResetResponse : public Base_Type {
  BITSTRING field_resetType;
public:
  HardResetResponse();
  HardResetResponse(const BITSTRING& par_resetType);
  HardResetResponse(const HardResetResponse& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  HardResetResponse& operator=(const HardResetResponse& other_value);
  boolean operator==(const HardResetResponse& other_value) const;
  inline boolean operator!=(const HardResetResponse& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& resetType()
    {return field_resetType;}
  inline const BITSTRING& resetType() const
    {return field_resetType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const HardResetResponse& other_value);
void copy_template(const HardResetResponse_template& other_value);

public:
HardResetResponse_template();
HardResetResponse_template(template_sel other_value);
HardResetResponse_template(const HardResetResponse& other_value);
HardResetResponse_template(const OPTIONAL<HardResetResponse>& other_value);
HardResetResponse_template(const HardResetResponse_template& other_value);
~HardResetResponse_template();
HardResetResponse_template& operator=(template_sel other_value);
HardResetResponse_template& operator=(const HardResetResponse& other_value);
HardResetResponse_template& operator=(const OPTIONAL<HardResetResponse>& other_value);
HardResetResponse_template& operator=(const HardResetResponse_template& other_value);
boolean match(const HardResetResponse& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
HardResetResponse valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
HardResetResponse_template& list_item(unsigned int list_index) const;
BITSTRING_template& resetType();
const BITSTRING_template& resetType() const;
int size_of() const;
void log() const;
void log_match(const HardResetResponse& 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 KeyOffOnResetResponse : public Base_Type {
  BITSTRING field_resetType;
public:
  KeyOffOnResetResponse();
  KeyOffOnResetResponse(const BITSTRING& par_resetType);
  KeyOffOnResetResponse(const KeyOffOnResetResponse& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  KeyOffOnResetResponse& operator=(const KeyOffOnResetResponse& other_value);
  boolean operator==(const KeyOffOnResetResponse& other_value) const;
  inline boolean operator!=(const KeyOffOnResetResponse& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& resetType()
    {return field_resetType;}
  inline const BITSTRING& resetType() const
    {return field_resetType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const KeyOffOnResetResponse& other_value);
void copy_template(const KeyOffOnResetResponse_template& other_value);

public:
KeyOffOnResetResponse_template();
KeyOffOnResetResponse_template(template_sel other_value);
KeyOffOnResetResponse_template(const KeyOffOnResetResponse& other_value);
KeyOffOnResetResponse_template(const OPTIONAL<KeyOffOnResetResponse>& other_value);
KeyOffOnResetResponse_template(const KeyOffOnResetResponse_template& other_value);
~KeyOffOnResetResponse_template();
KeyOffOnResetResponse_template& operator=(template_sel other_value);
KeyOffOnResetResponse_template& operator=(const KeyOffOnResetResponse& other_value);
KeyOffOnResetResponse_template& operator=(const OPTIONAL<KeyOffOnResetResponse>& other_value);
KeyOffOnResetResponse_template& operator=(const KeyOffOnResetResponse_template& other_value);
boolean match(const KeyOffOnResetResponse& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
KeyOffOnResetResponse valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
KeyOffOnResetResponse_template& list_item(unsigned int list_index) const;
BITSTRING_template& resetType();
const BITSTRING_template& resetType() const;
int size_of() const;
void log() const;
void log_match(const KeyOffOnResetResponse& 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 SoftResetResponse : public Base_Type {
  BITSTRING field_resetType;
public:
  SoftResetResponse();
  SoftResetResponse(const BITSTRING& par_resetType);
  SoftResetResponse(const SoftResetResponse& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  SoftResetResponse& operator=(const SoftResetResponse& other_value);
  boolean operator==(const SoftResetResponse& other_value) const;
  inline boolean operator!=(const SoftResetResponse& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& resetType()
    {return field_resetType;}
  inline const BITSTRING& resetType() const
    {return field_resetType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const SoftResetResponse& other_value);
void copy_template(const SoftResetResponse_template& other_value);

public:
SoftResetResponse_template();
SoftResetResponse_template(template_sel other_value);
SoftResetResponse_template(const SoftResetResponse& other_value);
SoftResetResponse_template(const OPTIONAL<SoftResetResponse>& other_value);
SoftResetResponse_template(const SoftResetResponse_template& other_value);
~SoftResetResponse_template();
SoftResetResponse_template& operator=(template_sel other_value);
SoftResetResponse_template& operator=(const SoftResetResponse& other_value);
SoftResetResponse_template& operator=(const OPTIONAL<SoftResetResponse>& other_value);
SoftResetResponse_template& operator=(const SoftResetResponse_template& other_value);
boolean match(const SoftResetResponse& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
SoftResetResponse valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SoftResetResponse_template& list_item(unsigned int list_index) const;
BITSTRING_template& resetType();
const BITSTRING_template& resetType() const;
int size_of() const;
void log() const;
void log_match(const SoftResetResponse& 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 EnableRapidPowerShutDownResponse : public Base_Type {
  BITSTRING field_resetType;
  OCTETSTRING field_powerDownTime;
public:
  EnableRapidPowerShutDownResponse();
  EnableRapidPowerShutDownResponse(const BITSTRING& par_resetType,
    const OCTETSTRING& par_powerDownTime);
  EnableRapidPowerShutDownResponse(const EnableRapidPowerShutDownResponse& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  EnableRapidPowerShutDownResponse& operator=(const EnableRapidPowerShutDownResponse& other_value);
  boolean operator==(const EnableRapidPowerShutDownResponse& other_value) const;
  inline boolean operator!=(const EnableRapidPowerShutDownResponse& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& resetType()
    {return field_resetType;}
  inline const BITSTRING& resetType() const
    {return field_resetType;}
  inline OCTETSTRING& powerDownTime()
    {return field_powerDownTime;}
  inline const OCTETSTRING& powerDownTime() const
    {return field_powerDownTime;}
  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);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

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

void set_specific();
void copy_value(const EnableRapidPowerShutDownResponse& other_value);
void copy_template(const EnableRapidPowerShutDownResponse_template& other_value);

public:
EnableRapidPowerShutDownResponse_template();
EnableRapidPowerShutDownResponse_template(template_sel other_value);
EnableRapidPowerShutDownResponse_template(const EnableRapidPowerShutDownResponse& other_value);
EnableRapidPowerShutDownResponse_template(const OPTIONAL<EnableRapidPowerShutDownResponse>& other_value);
EnableRapidPowerShutDownResponse_template(const EnableRapidPowerShutDownResponse_template& other_value);
~EnableRapidPowerShutDownResponse_template();
EnableRapidPowerShutDownResponse_template& operator=(template_sel other_value);
EnableRapidPowerShutDownResponse_template& operator=(const EnableRapidPowerShutDownResponse& other_value);
EnableRapidPowerShutDownResponse_template& operator=(const OPTIONAL<EnableRapidPowerShutDownResponse>& other_value);
EnableRapidPowerShutDownResponse_template& operator=(const EnableRapidPowerShutDownResponse_template& other_value);
boolean match(const EnableRapidPowerShutDownResponse& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
EnableRapidPowerShutDownResponse valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
EnableRapidPowerShutDownResponse_template& list_item(unsigned int list_index) const;
BITSTRING_template& resetType();
const BITSTRING_template& resetType() const;
OCTETSTRING_template& powerDownTime();
const OCTETSTRING_template& powerDownTime() const;
int size_of() const;
void log() const;
void log_match(const EnableRapidPowerShutDownResponse& 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 DisableRapidPowerShutDownResponse : public Base_Type {
  BITSTRING field_resetType;
public:
  DisableRapidPowerShutDownResponse();
  DisableRapidPowerShutDownResponse(const BITSTRING& par_resetType);
  DisableRapidPowerShutDownResponse(const DisableRapidPowerShutDownResponse& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DisableRapidPowerShutDownResponse& operator=(const DisableRapidPowerShutDownResponse& other_value);
  boolean operator==(const DisableRapidPowerShutDownResponse& other_value) const;
  inline boolean operator!=(const DisableRapidPowerShutDownResponse& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BITSTRING& resetType()
    {return field_resetType;}
  inline const BITSTRING& resetType() const
    {return field_resetType;}
  inline int size_of() const
    {return 1;}
  void log() const;
  void set_param(Module_Param& param);
  void set_implicit_omit();
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, TTCN_EncDec::coding_t, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err