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

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

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

#ifndef BTS__Tests__VAMOS_HH
#define BTS__Tests__VAMOS_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 "BTS_Tests.hh"

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

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

#undef BTS__Tests__VAMOS_HH
#endif

namespace BTS__Tests__VAMOS {

/* Forward declarations of classes */

class ChanNrModeTest;
class ChanNrModeTest_template;
class ChanNrModeSet;
class ChanNrModeSet_template;
class ChanNrMode;
class ChanNrMode_template;

} /* end of namespace */

#ifndef BTS__Tests__VAMOS_HH
#define BTS__Tests__VAMOS_HH

namespace BTS__Tests__VAMOS {

/* Class definitions */

class ChanNrModeTest : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
ChanNrModeSet **value_elements;
} *val_ptr;

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

public:
  typedef ChanNrModeSet of_type;
ChanNrModeTest();
ChanNrModeTest(null_type other_value);
ChanNrModeTest(const ChanNrModeTest& other_value);
~ChanNrModeTest();

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

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

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

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

ChanNrModeTest operator+(const ChanNrModeTest& other_value) const;

ChanNrModeTest substr(int index, int returncount) const;

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

ChanNrModeTest replace(int index, int len, const ChanNrModeTest_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class ChanNrModeTest_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
ChanNrModeSet_template **value_elements;
} single_value;
struct {
unsigned int n_values;
ChanNrModeTest_template *list_value;
} value_list;
struct {
ChanNrModeTest_template* precondition;
ChanNrModeTest_template* implied_template;
} implication_;
dynmatch_struct<ChanNrModeTest>* dyn_match;
};
void copy_value(const ChanNrModeTest& other_value);
void copy_template(const ChanNrModeTest_template& other_value);
static boolean match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);

public:
ChanNrModeTest_template();
ChanNrModeTest_template(template_sel other_value);
ChanNrModeTest_template(null_type other_value);
ChanNrModeTest_template(const ChanNrModeTest& other_value);
ChanNrModeTest_template(const OPTIONAL<ChanNrModeTest>& other_value);
ChanNrModeTest_template(ChanNrModeTest_template* p_precondition, ChanNrModeTest_template* p_implied_template);
ChanNrModeTest_template(Dynamic_Match_Interface<ChanNrModeTest>* p_dyn_match);
ChanNrModeTest_template(const ChanNrModeTest_template& other_value);
~ChanNrModeTest_template();

void clean_up();
ChanNrModeTest_template& operator=(template_sel other_value);
ChanNrModeTest_template& operator=(null_type other_value);
ChanNrModeTest_template& operator=(const ChanNrModeTest& other_value);
ChanNrModeTest_template& operator=(const OPTIONAL<ChanNrModeTest>& other_value);
ChanNrModeTest_template& operator=(const ChanNrModeTest_template& other_value);

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

void set_size(int new_size);
int n_elem() const;
int size_of(boolean is_size) const;
inline int size_of() const { return size_of(TRUE); }
inline int lengthof() const { return size_of(FALSE); }
boolean match(const ChanNrModeTest& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
ChanNrModeTest valueof() const;
ChanNrModeTest substr(int index, int returncount) const;

ChanNrModeTest replace(int index, int len, const ChanNrModeTest_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
ChanNrModeTest_template& list_item(unsigned int list_index);
void log() const;
void log_match(const ChanNrModeTest& 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_implicit_omit();
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean get_istemplate_kind(const char* type) const;
};

class ChanNrModeSet : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
ChanNrMode **value_elements;
} *val_ptr;

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

public:
  typedef ChanNrMode of_type;
ChanNrModeSet();
ChanNrModeSet(null_type other_value);
ChanNrModeSet(const ChanNrModeSet& other_value);
~ChanNrModeSet();

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

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

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

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

ChanNrModeSet operator+(const ChanNrModeSet& other_value) const;

ChanNrModeSet substr(int index, int returncount) const;

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

ChanNrModeSet replace(int index, int len, const ChanNrModeSet_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class ChanNrModeSet_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
ChanNrMode_template **value_elements;
} single_value;
struct {
unsigned int n_values;
ChanNrModeSet_template *list_value;
} value_list;
struct {
ChanNrModeSet_template* precondition;
ChanNrModeSet_template* implied_template;
} implication_;
dynmatch_struct<ChanNrModeSet>* dyn_match;
};
void copy_value(const ChanNrModeSet& other_value);
void copy_template(const ChanNrModeSet_template& other_value);
static boolean match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);

public:
ChanNrModeSet_template();
ChanNrModeSet_template(template_sel other_value);
ChanNrModeSet_template(null_type other_value);
ChanNrModeSet_template(const ChanNrModeSet& other_value);
ChanNrModeSet_template(const OPTIONAL<ChanNrModeSet>& other_value);
ChanNrModeSet_template(ChanNrModeSet_template* p_precondition, ChanNrModeSet_template* p_implied_template);
ChanNrModeSet_template(Dynamic_Match_Interface<ChanNrModeSet>* p_dyn_match);
ChanNrModeSet_template(const ChanNrModeSet_template& other_value);
~ChanNrModeSet_template();

void clean_up();
ChanNrModeSet_template& operator=(template_sel other_value);
ChanNrModeSet_template& operator=(null_type other_value);
ChanNrModeSet_template& operator=(const ChanNrModeSet& other_value);
ChanNrModeSet_template& operator=(const OPTIONAL<ChanNrModeSet>& other_value);
ChanNrModeSet_template& operator=(const ChanNrModeSet_template& other_value);

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

void set_size(int new_size);
int n_elem() const;
int size_of(boolean is_size) const;
inline int size_of() const { return size_of(TRUE); }
inline int lengthof() const { return size_of(FALSE); }
boolean match(const ChanNrModeSet& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
ChanNrModeSet valueof() const;
ChanNrModeSet substr(int index, int returncount) const;

ChanNrModeSet replace(int index, int len, const ChanNrModeSet_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
ChanNrModeSet_template& list_item(unsigned int list_index);
void log() const;
void log_match(const ChanNrModeSet& 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_implicit_omit();
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean get_istemplate_kind(const char* type) const;
};

class ChanNrMode {
  GSM__Types::RslChannelNr field_chan__nr;
  RSL__Types::RSL__IE__ChannelMode field_chan__mode;
public:
  ChanNrMode();
  ChanNrMode(const GSM__Types::RslChannelNr& par_chan__nr,
    const RSL__Types::RSL__IE__ChannelMode& par_chan__mode);
  ChanNrMode(const ChanNrMode& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  ChanNrMode& operator=(const ChanNrMode& other_value);
  boolean operator==(const ChanNrMode& other_value) const;
  inline boolean operator!=(const ChanNrMode& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline GSM__Types::RslChannelNr& chan__nr()
    {return field_chan__nr;}
  inline const GSM__Types::RslChannelNr& chan__nr() const
    {return field_chan__nr;}
  inline RSL__Types::RSL__IE__ChannelMode& chan__mode()
    {return field_chan__mode;}
  inline const RSL__Types::RSL__IE__ChannelMode& chan__mode() const
    {return field_chan__mode;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
};

class ChanNrMode_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
ChanNrMode_template *list_value;
} value_list;
struct {
ChanNrMode_template* precondition;
ChanNrMode_template* implied_template;
} implication_;
dynmatch_struct<ChanNrMode>* dyn_match;
};

void set_specific();
void copy_value(const ChanNrMode& other_value);
void copy_template(const ChanNrMode_template& other_value);

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


/* Function prototypes */

extern boolean operator==(null_type null_value, const ChanNrModeTest& other_value);
inline boolean operator!=(null_type null_value, const ChanNrModeTest& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const ChanNrModeSet& other_value);
inline boolean operator!=(null_type null_value, const ChanNrModeSet& other_value) { return !(null_value == other_value); }
extern ChanNrModeTest_template ChanNrModeTestVFF(const INTEGER& tn);
extern ChanNrModeTest_template ChanNrModeTestVHH(const INTEGER& tn);
extern ChanNrModeTest_template ChanNrModeTestHVHH(const INTEGER& tn);
extern void f__TC__vamos__exec__async(const ChanNrModeTest& test, const BTS__Tests::void__fn& handler);
extern void start_f__TC__vamos__exec__async(const COMPONENT& component_reference, const ChanNrModeTest& test, const BTS__Tests::void__fn& handler);
extern void f__TC__vamos__chan__act(const CHARSTRING& );
extern void start_f__TC__vamos__chan__act(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__vamos__chan__act__vff(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__act__dyn__ipa__vff(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__act__dyn__osmo__vff(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__act__vhh(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__act__dyn__osmo__vhh(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__act__hvhh(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__act__dyn__osmo__hvhh(boolean has_timer, double timer_value);
extern void f__TC__vamos__chan__mode__modify(const CHARSTRING& );
extern void start_f__TC__vamos__chan__mode__modify(const COMPONENT& component_reference, const CHARSTRING& id);
extern verdicttype testcase_TC__vamos__chan__mode__modify__vff(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__mode__modify__dyn__ipa__vff(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__mode__modify__dyn__osmo__vff(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__mode__modify__vhh(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__mode__modify__dyn__osmo__vhh(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__mode__modify__hvhh(boolean has_timer, double timer_value);
extern verdicttype testcase_TC__vamos__chan__mode__modify__dyn__osmo__hvhh(boolean has_timer, double timer_value);
extern void module_control_part();
extern void pre_init_module();
extern void post_init_module();
extern boolean start_ptc_function(const char *function_name, Text_Buf& function_arguments);

/* Global variable declarations */

extern const TTCN_Typedescriptor_t ChanNrModeTest_descr_;
extern const TTCN_Typedescriptor_t ChanNrModeSet_descr_;
extern UNIVERSAL_CHARSTRING ChanNrMode_chan__nr_default_coding;
extern UNIVERSAL_CHARSTRING ChanNrMode_chan__mode_default_coding;
extern const TTCN_Typedescriptor_t ChanNrMode_descr_;
extern const RSL__Types::RSL__IE_template& ts__RSL__IE__OsmoTSC;
extern RSL__Types::RSL__IE_template template_ts__RSL__IE__OsmoTSC;
extern const CHARSTRING cs_0,
cs_1,
cs_2;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
