// 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 LAPDm__RAW__PT_HH
#define LAPDm__RAW__PT_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 "L1CTL_PortType.hh"
#include "LAPDm_Types.hh"
#include "RLCMAC_Types.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 LAPDm__RAW__PT_HH
#endif

namespace LAPDm__RAW__PT {

/* Forward declarations of classes */

typedef PreGenRecordOf::PREGEN__RECORD__OF__INTEGER TfiUsfArr;
typedef PreGenRecordOf::PREGEN__RECORD__OF__INTEGER_template TfiUsfArr_template;
class BCCH__tune__req;
class BCCH__tune__req_template;
class DCCH__establish__req;
class DCCH__establish__req_template;
class DCCH__establish__res;
class DCCH__establish__res_template;
class DCCH__switch__req;
class DCCH__switch__req_template;
class DCCH__switch__res;
class DCCH__switch__res_template;
typedef PreGenRecordOf::PREGEN__RECORD__OF__INTEGER TfiList;
typedef PreGenRecordOf::PREGEN__RECORD__OF__INTEGER_template TfiList_template;
class TbfPars;
class TbfPars_template;
class TbfParsPerTs;
class TbfParsPerTs_template;
class TBF__UL__establish__res;
class TBF__UL__establish__res_template;
class DCCH__release__req;
class DCCH__release__req_template;
class LAPDm__ph__data;
class LAPDm__ph__data_template;
class TBF__UL__establish__req;
class TBF__UL__establish__req_template;
class TBF__DL__establish__req;
class TBF__DL__establish__req_template;
class RLCMAC__ph__data__ind;
class RLCMAC__ph__data__ind_template;
class RLCMAC__ph__data__req__dyn;
class RLCMAC__ph__data__req__dyn_template;
class RLCMAC__ph__data__req__abs;
class RLCMAC__ph__data__req__abs_template;
class RLCMAC__ph__data__req;
class RLCMAC__ph__data__req_template;
class LAPDm__SP__PT;
class LAPDm__PT;
class ph__state__enum;
class ph__state__enum_template;

} /* end of namespace */

#ifndef LAPDm__RAW__PT_HH
#define LAPDm__RAW__PT_HH

namespace LAPDm__RAW__PT {

/* Type definitions */

typedef INTEGER TbfNr;
typedef INTEGER_template TbfNr_template;
typedef COMPONENT lapdm__CT;
typedef COMPONENT_template lapdm__CT_template;

/* Class definitions */

class BCCH__tune__req {
  GSM__Types::GsmBandArfcn field_arfcn;
  BOOLEAN field_combined__ccch;
public:
  BCCH__tune__req();
  BCCH__tune__req(const GSM__Types::GsmBandArfcn& par_arfcn,
    const BOOLEAN& par_combined__ccch);
  BCCH__tune__req(const BCCH__tune__req& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  BCCH__tune__req& operator=(const BCCH__tune__req& other_value);
  boolean operator==(const BCCH__tune__req& other_value) const;
  inline boolean operator!=(const BCCH__tune__req& 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::GsmBandArfcn& arfcn()
    {return field_arfcn;}
  inline const GSM__Types::GsmBandArfcn& arfcn() const
    {return field_arfcn;}
  inline BOOLEAN& combined__ccch()
    {return field_combined__ccch;}
  inline const BOOLEAN& combined__ccch() const
    {return field_combined__ccch;}
  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 BCCH__tune__req_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
BCCH__tune__req_template *list_value;
} value_list;
struct {
BCCH__tune__req_template* precondition;
BCCH__tune__req_template* implied_template;
} implication_;
dynmatch_struct<BCCH__tune__req>* dyn_match;
};

void set_specific();
void copy_value(const BCCH__tune__req& other_value);
void copy_template(const BCCH__tune__req_template& other_value);

public:
BCCH__tune__req_template();
BCCH__tune__req_template(template_sel other_value);
BCCH__tune__req_template(const BCCH__tune__req& other_value);
BCCH__tune__req_template(const OPTIONAL<BCCH__tune__req>& other_value);
BCCH__tune__req_template(BCCH__tune__req_template* p_precondition, BCCH__tune__req_template* p_implied_template);
BCCH__tune__req_template(Dynamic_Match_Interface<BCCH__tune__req>* p_dyn_match);
BCCH__tune__req_template(const BCCH__tune__req_template& other_value);
~BCCH__tune__req_template();
BCCH__tune__req_template& operator=(template_sel other_value);
BCCH__tune__req_template& operator=(const BCCH__tune__req& other_value);
BCCH__tune__req_template& operator=(const OPTIONAL<BCCH__tune__req>& other_value);
BCCH__tune__req_template& operator=(const BCCH__tune__req_template& other_value);
boolean match(const BCCH__tune__req& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
BCCH__tune__req valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
BCCH__tune__req_template& list_item(unsigned int list_index) const;
GSM__Types::GsmBandArfcn_template& arfcn();
const GSM__Types::GsmBandArfcn_template& arfcn() const;
BOOLEAN_template& combined__ccch();
const BOOLEAN_template& combined__ccch() const;
int size_of() const;
void log() const;
void log_match(const BCCH__tune__req& 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;
};

class DCCH__establish__req {
  INTEGER field_ra;
public:
  DCCH__establish__req();
  DCCH__establish__req(const INTEGER& par_ra);
  DCCH__establish__req(const DCCH__establish__req& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DCCH__establish__req& operator=(const DCCH__establish__req& other_value);
  boolean operator==(const DCCH__establish__req& other_value) const;
  inline boolean operator!=(const DCCH__establish__req& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& ra()
    {return field_ra;}
  inline const INTEGER& ra() const
    {return field_ra;}
  inline int size_of() const
    {return 1;}
  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 DCCH__establish__req_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
DCCH__establish__req_template *list_value;
} value_list;
struct {
DCCH__establish__req_template* precondition;
DCCH__establish__req_template* implied_template;
} implication_;
dynmatch_struct<DCCH__establish__req>* dyn_match;
};

void set_specific();
void copy_value(const DCCH__establish__req& other_value);
void copy_template(const DCCH__establish__req_template& other_value);

public:
DCCH__establish__req_template();
DCCH__establish__req_template(template_sel other_value);
DCCH__establish__req_template(const DCCH__establish__req& other_value);
DCCH__establish__req_template(const OPTIONAL<DCCH__establish__req>& other_value);
DCCH__establish__req_template(DCCH__establish__req_template* p_precondition, DCCH__establish__req_template* p_implied_template);
DCCH__establish__req_template(Dynamic_Match_Interface<DCCH__establish__req>* p_dyn_match);
DCCH__establish__req_template(const DCCH__establish__req_template& other_value);
~DCCH__establish__req_template();
DCCH__establish__req_template& operator=(template_sel other_value);
DCCH__establish__req_template& operator=(const DCCH__establish__req& other_value);
DCCH__establish__req_template& operator=(const OPTIONAL<DCCH__establish__req>& other_value);
DCCH__establish__req_template& operator=(const DCCH__establish__req_template& other_value);
boolean match(const DCCH__establish__req& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DCCH__establish__req valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DCCH__establish__req_template& list_item(unsigned int list_index) const;
INTEGER_template& ra();
const INTEGER_template& ra() const;
int size_of() const;
void log() const;
void log_match(const DCCH__establish__req& 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;
};

class DCCH__establish__res {
  OPTIONAL< GSM__RR__Types::ChannelDescription > field_chan__desc;
  OPTIONAL< CHARSTRING > field_err;
public:
  DCCH__establish__res();
  DCCH__establish__res(const OPTIONAL< GSM__RR__Types::ChannelDescription >& par_chan__desc,
    const OPTIONAL< CHARSTRING >& par_err);
  DCCH__establish__res(const DCCH__establish__res& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DCCH__establish__res& operator=(const DCCH__establish__res& other_value);
  boolean operator==(const DCCH__establish__res& other_value) const;
  inline boolean operator!=(const DCCH__establish__res& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OPTIONAL< GSM__RR__Types::ChannelDescription >& chan__desc()
    {return field_chan__desc;}
  inline const OPTIONAL< GSM__RR__Types::ChannelDescription >& chan__desc() const
    {return field_chan__desc;}
  inline OPTIONAL< CHARSTRING >& err()
    {return field_err;}
  inline const OPTIONAL< CHARSTRING >& err() const
    {return field_err;}
  int size_of() 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 DCCH__establish__res_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
DCCH__establish__res_template *list_value;
} value_list;
struct {
DCCH__establish__res_template* precondition;
DCCH__establish__res_template* implied_template;
} implication_;
dynmatch_struct<DCCH__establish__res>* dyn_match;
};

void set_specific();
void copy_value(const DCCH__establish__res& other_value);
void copy_template(const DCCH__establish__res_template& other_value);

public:
DCCH__establish__res_template();
DCCH__establish__res_template(template_sel other_value);
DCCH__establish__res_template(const DCCH__establish__res& other_value);
DCCH__establish__res_template(const OPTIONAL<DCCH__establish__res>& other_value);
DCCH__establish__res_template(DCCH__establish__res_template* p_precondition, DCCH__establish__res_template* p_implied_template);
DCCH__establish__res_template(Dynamic_Match_Interface<DCCH__establish__res>* p_dyn_match);
DCCH__establish__res_template(const DCCH__establish__res_template& other_value);
~DCCH__establish__res_template();
DCCH__establish__res_template& operator=(template_sel other_value);
DCCH__establish__res_template& operator=(const DCCH__establish__res& other_value);
DCCH__establish__res_template& operator=(const OPTIONAL<DCCH__establish__res>& other_value);
DCCH__establish__res_template& operator=(const DCCH__establish__res_template& other_value);
boolean match(const DCCH__establish__res& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DCCH__establish__res valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DCCH__establish__res_template& list_item(unsigned int list_index) const;
GSM__RR__Types::ChannelDescription_template& chan__desc();
const GSM__RR__Types::ChannelDescription_template& chan__desc() const;
CHARSTRING_template& err();
const CHARSTRING_template& err() const;
int size_of() const;
void log() const;
void log_match(const DCCH__establish__res& 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;
};

class DCCH__switch__req {
  GSM__RR__Types::ChannelDescription field_chan__desc;
  OPTIONAL< L1CTL__Types::L1ctlMA > field_ma;
public:
  DCCH__switch__req();
  DCCH__switch__req(const GSM__RR__Types::ChannelDescription& par_chan__desc,
    const OPTIONAL< L1CTL__Types::L1ctlMA >& par_ma);
  DCCH__switch__req(const DCCH__switch__req& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DCCH__switch__req& operator=(const DCCH__switch__req& other_value);
  boolean operator==(const DCCH__switch__req& other_value) const;
  inline boolean operator!=(const DCCH__switch__req& 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__RR__Types::ChannelDescription& chan__desc()
    {return field_chan__desc;}
  inline const GSM__RR__Types::ChannelDescription& chan__desc() const
    {return field_chan__desc;}
  inline OPTIONAL< L1CTL__Types::L1ctlMA >& ma()
    {return field_ma;}
  inline const OPTIONAL< L1CTL__Types::L1ctlMA >& ma() const
    {return field_ma;}
  int size_of() 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 DCCH__switch__req_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
DCCH__switch__req_template *list_value;
} value_list;
struct {
DCCH__switch__req_template* precondition;
DCCH__switch__req_template* implied_template;
} implication_;
dynmatch_struct<DCCH__switch__req>* dyn_match;
};

void set_specific();
void copy_value(const DCCH__switch__req& other_value);
void copy_template(const DCCH__switch__req_template& other_value);

public:
DCCH__switch__req_template();
DCCH__switch__req_template(template_sel other_value);
DCCH__switch__req_template(const DCCH__switch__req& other_value);
DCCH__switch__req_template(const OPTIONAL<DCCH__switch__req>& other_value);
DCCH__switch__req_template(DCCH__switch__req_template* p_precondition, DCCH__switch__req_template* p_implied_template);
DCCH__switch__req_template(Dynamic_Match_Interface<DCCH__switch__req>* p_dyn_match);
DCCH__switch__req_template(const DCCH__switch__req_template& other_value);
~DCCH__switch__req_template();
DCCH__switch__req_template& operator=(template_sel other_value);
DCCH__switch__req_template& operator=(const DCCH__switch__req& other_value);
DCCH__switch__req_template& operator=(const OPTIONAL<DCCH__switch__req>& other_value);
DCCH__switch__req_template& operator=(const DCCH__switch__req_template& other_value);
boolean match(const DCCH__switch__req& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DCCH__switch__req valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DCCH__switch__req_template& list_item(unsigned int list_index) const;
GSM__RR__Types::ChannelDescription_template& chan__desc();
const GSM__RR__Types::ChannelDescription_template& chan__desc() const;
L1CTL__Types::L1ctlMA_template& ma();
const L1CTL__Types::L1ctlMA_template& ma() const;
int size_of() const;
void log() const;
void log_match(const DCCH__switch__req& 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;
};

class DCCH__switch__res {
  OPTIONAL< CHARSTRING > field_err;
public:
  DCCH__switch__res();
  DCCH__switch__res(const OPTIONAL< CHARSTRING >& par_err);
  DCCH__switch__res(const DCCH__switch__res& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  DCCH__switch__res& operator=(const DCCH__switch__res& other_value);
  boolean operator==(const DCCH__switch__res& other_value) const;
  inline boolean operator!=(const DCCH__switch__res& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OPTIONAL< CHARSTRING >& err()
    {return field_err;}
  inline const OPTIONAL< CHARSTRING >& err() const
    {return field_err;}
  int size_of() 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 DCCH__switch__res_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
DCCH__switch__res_template *list_value;
} value_list;
struct {
DCCH__switch__res_template* precondition;
DCCH__switch__res_template* implied_template;
} implication_;
dynmatch_struct<DCCH__switch__res>* dyn_match;
};

void set_specific();
void copy_value(const DCCH__switch__res& other_value);
void copy_template(const DCCH__switch__res_template& other_value);

public:
DCCH__switch__res_template();
DCCH__switch__res_template(template_sel other_value);
DCCH__switch__res_template(const DCCH__switch__res& other_value);
DCCH__switch__res_template(const OPTIONAL<DCCH__switch__res>& other_value);
DCCH__switch__res_template(DCCH__switch__res_template* p_precondition, DCCH__switch__res_template* p_implied_template);
DCCH__switch__res_template(Dynamic_Match_Interface<DCCH__switch__res>* p_dyn_match);
DCCH__switch__res_template(const DCCH__switch__res_template& other_value);
~DCCH__switch__res_template();
DCCH__switch__res_template& operator=(template_sel other_value);
DCCH__switch__res_template& operator=(const DCCH__switch__res& other_value);
DCCH__switch__res_template& operator=(const OPTIONAL<DCCH__switch__res>& other_value);
DCCH__switch__res_template& operator=(const DCCH__switch__res_template& other_value);
boolean match(const DCCH__switch__res& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
DCCH__switch__res valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DCCH__switch__res_template& list_item(unsigned int list_index) const;
CHARSTRING_template& err();
const CHARSTRING_template& err() const;
int size_of() const;
void log() const;
void log_match(const DCCH__switch__res& 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;
};

class TbfPars {
  OPTIONAL< INTEGER > field_arfcn;
  TfiList field_tfi;
public:
  TbfPars();
  TbfPars(const OPTIONAL< INTEGER >& par_arfcn,
    const TfiList& par_tfi);
  TbfPars(const TbfPars& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  TbfPars& operator=(const TbfPars& other_value);
  boolean operator==(const TbfPars& other_value) const;
  inline boolean operator!=(const TbfPars& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OPTIONAL< INTEGER >& arfcn()
    {return field_arfcn;}
  inline const OPTIONAL< INTEGER >& arfcn() const
    {return field_arfcn;}
  inline TfiList& tfi()
    {return field_tfi;}
  inline const TfiList& tfi() const
    {return field_tfi;}
  int size_of() 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 TbfPars_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
TbfPars_template *list_value;
} value_list;
struct {
TbfPars_template* precondition;
TbfPars_template* implied_template;
} implication_;
dynmatch_struct<TbfPars>* dyn_match;
};

void set_specific();
void copy_value(const TbfPars& other_value);
void copy_template(const TbfPars_template& other_value);

public:
TbfPars_template();
TbfPars_template(template_sel other_value);
TbfPars_template(const TbfPars& other_value);
TbfPars_template(const OPTIONAL<TbfPars>& other_value);
TbfPars_template(TbfPars_template* p_precondition, TbfPars_template* p_implied_template);
TbfPars_template(Dynamic_Match_Interface<TbfPars>* p_dyn_match);
TbfPars_template(const TbfPars_template& other_value);
~TbfPars_template();
TbfPars_template& operator=(template_sel other_value);
TbfPars_template& operator=(const TbfPars& other_value);
TbfPars_template& operator=(const OPTIONAL<TbfPars>& other_value);
TbfPars_template& operator=(const TbfPars_template& other_value);
boolean match(const TbfPars& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
TbfPars valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
TbfPars_template& list_item(unsigned int list_index) const;
INTEGER_template& arfcn();
const INTEGER_template& arfcn() const;
TfiList_template& tfi();
const TfiList_template& tfi() const;
int size_of() const;
void log() const;
void log_match(const TbfPars& 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;
};

class TbfParsPerTs : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
TbfPars **value_elements;
} *val_ptr;

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

public:
  typedef TbfPars of_type;
TbfParsPerTs();
TbfParsPerTs(null_type other_value);
TbfParsPerTs(const TbfParsPerTs& other_value);
~TbfParsPerTs();

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

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

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

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

TbfParsPerTs operator+(const TbfParsPerTs& other_value) const;

TbfParsPerTs substr(int index, int returncount) const;

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

TbfParsPerTs replace(int index, int len, const TbfParsPerTs_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 TbfParsPerTs_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
TbfPars_template **value_elements;
} single_value;
struct {
unsigned int n_values;
TbfParsPerTs_template *list_value;
} value_list;
struct {
TbfParsPerTs_template* precondition;
TbfParsPerTs_template* implied_template;
} implication_;
dynmatch_struct<TbfParsPerTs>* dyn_match;
};
void copy_value(const TbfParsPerTs& other_value);
void copy_template(const TbfParsPerTs_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:
TbfParsPerTs_template();
TbfParsPerTs_template(template_sel other_value);
TbfParsPerTs_template(null_type other_value);
TbfParsPerTs_template(const TbfParsPerTs& other_value);
TbfParsPerTs_template(const OPTIONAL<TbfParsPerTs>& other_value);
TbfParsPerTs_template(TbfParsPerTs_template* p_precondition, TbfParsPerTs_template* p_implied_template);
TbfParsPerTs_template(Dynamic_Match_Interface<TbfParsPerTs>* p_dyn_match);
TbfParsPerTs_template(const TbfParsPerTs_template& other_value);
~TbfParsPerTs_template();

void clean_up();
TbfParsPerTs_template& operator=(template_sel other_value);
TbfParsPerTs_template& operator=(null_type other_value);
TbfParsPerTs_template& operator=(const TbfParsPerTs& other_value);
TbfParsPerTs_template& operator=(const OPTIONAL<TbfParsPerTs>& other_value);
TbfParsPerTs_template& operator=(const TbfParsPerTs_template& other_value);

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

TbfParsPerTs replace(int index, int len, const TbfParsPerTs_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
TbfParsPerTs_template& list_item(unsigned int list_index);
void log() const;
void log_match(const TbfParsPerTs& 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 TBF__UL__establish__res {
  OPTIONAL< TbfPars > field_pars;
  OPTIONAL< CHARSTRING > field_err;
public:
  TBF__UL__establish__res();
  TBF__UL__establish__res(const OPTIONAL< TbfPars >& par_pars,
    const OPTIONAL< CHARSTRING >& par_err);
  TBF__UL__establish__res(const TBF__UL__establish__res& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  TBF__UL__establish__res& operator=(const TBF__UL__establish__res& other_value);
  boolean operator==(const TBF__UL__establish__res& other_value) const;
  inline boolean operator!=(const TBF__UL__establish__res& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OPTIONAL< TbfPars >& pars()
    {return field_pars;}
  inline const OPTIONAL< TbfPars >& pars() const
    {return field_pars;}
  inline OPTIONAL< CHARSTRING >& err()
    {return field_err;}
  inline const OPTIONAL< CHARSTRING >& err() const
    {return field_err;}
  int size_of() 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 TBF__UL__establish__res_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
TBF__UL__establish__res_template *list_value;
} value_list;
struct {
TBF__UL__establish__res_template* precondition;
TBF__UL__establish__res_template* implied_template;
} implication_;
dynmatch_struct<TBF__UL__establish__res>* dyn_match;
};

void set_specific();
void copy_value(const TBF__UL__establish__res& other_value);
void copy_template(const TBF__UL__establish__res_template& other_value);

public:
TBF__UL__establish__res_template();
TBF__UL__establish__res_template(template_sel other_value);
TBF__UL__establish__res_template(const TBF__UL__establish__res& other_value);
TBF__UL__establish__res_template(const OPTIONAL<TBF__UL__establish__res>& other_value);
TBF__UL__establish__res_template(TBF__UL__establish__res_template* p_precondition, TBF__UL__establish__res_template* p_implied_template);
TBF__UL__establish__res_template(Dynamic_Match_Interface<TBF__UL__establish__res>* p_dyn_match);
TBF__UL__establish__res_template(const TBF__UL__establish__res_template& other_value);
~TBF__UL__establish__res_template();
TBF__UL__establish__res_template& operator=(template_sel other_value);
TBF__UL__establish__res_template& operator=(const TBF__UL__establish__res& other_value);
TBF__UL__establish__res_template& operator=(const OPTIONAL<TBF__UL__establish__res>& other_value);
TBF__UL__establish__res_template& operator=(const TBF__UL__establish__res_template& other_value);
boolean match(const TBF__UL__establish__res& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
TBF__UL__establish__res valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
TBF__UL__establish__res_template& list_item(unsigned int list_index) const;
TbfPars_template& pars();
const TbfPars_template& pars() const;
CHARSTRING_template& err();
const CHARSTRING_template& err() const;
int size_of() const;
void log() const;
void log_match(const TBF__UL__establish__res& 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;
};

class DCCH__release__req : public Base_Type {
boolean bound_flag;
public:
DCCH__release__req();
DCCH__release__req(null_type other_value);
DCCH__release__req(const DCCH__release__req& other_value);
DCCH__release__req& operator=(null_type other_value);
DCCH__release__req& operator=(const DCCH__release__req& other_value);
boolean operator==(null_type other_value) const;
boolean operator==(const DCCH__release__req& other_value) const;
inline boolean operator!=(null_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const DCCH__release__req& other_value) const { return !(*this == other_value); }
inline boolean is_bound() const { return bound_flag; }
inline boolean is_present() const { return is_bound(); }
inline boolean is_value() const { return bound_flag; }
inline void clean_up() { bound_flag = FALSE; }
inline void must_bound(const char *err_msg) const { if (!bound_flag) TTCN_error("%s", err_msg); }
void log() const;
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class DCCH__release__req_template : public Base_Template {
union {
struct {
unsigned int n_values;
DCCH__release__req_template *list_value;
} value_list;
struct {
DCCH__release__req_template* precondition;
DCCH__release__req_template* implied_template;
} implication_;
dynmatch_struct<DCCH__release__req>* dyn_match;
};
void copy_template(const DCCH__release__req_template& other_value);

public:
DCCH__release__req_template();
DCCH__release__req_template(template_sel other_value);
DCCH__release__req_template(null_type other_value);
DCCH__release__req_template(const DCCH__release__req& other_value);
DCCH__release__req_template(const OPTIONAL<DCCH__release__req>& other_value);
DCCH__release__req_template(DCCH__release__req_template* p_precondition, DCCH__release__req_template* p_implied_template);
DCCH__release__req_template(Dynamic_Match_Interface<DCCH__release__req>* p_dyn_match);
DCCH__release__req_template(const DCCH__release__req_template& other_value);
~DCCH__release__req_template();
void clean_up();
DCCH__release__req_template& operator=(template_sel other_value);
DCCH__release__req_template& operator=(null_type other_value);
DCCH__release__req_template& operator=(const DCCH__release__req& other_value);
DCCH__release__req_template& operator=(const OPTIONAL<DCCH__release__req>& other_value);
DCCH__release__req_template& operator=(const DCCH__release__req_template& other_value);
boolean match(null_type other_value, boolean legacy = FALSE) const;
boolean match(const DCCH__release__req& other_value, boolean legacy = FALSE) const;
DCCH__release__req valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
DCCH__release__req_template& list_item(unsigned int list_index) const;
void log() const;
void log_match(const DCCH__release__req& 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 LAPDm__ph__data {
  BOOLEAN field_sacch;
  INTEGER field_sapi;
  LAPDm__Types::LapdmFrame field_lapdm;
public:
  LAPDm__ph__data();
  LAPDm__ph__data(const BOOLEAN& par_sacch,
    const INTEGER& par_sapi,
    const LAPDm__Types::LapdmFrame& par_lapdm);
  LAPDm__ph__data(const LAPDm__ph__data& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  LAPDm__ph__data& operator=(const LAPDm__ph__data& other_value);
  boolean operator==(const LAPDm__ph__data& other_value) const;
  inline boolean operator!=(const LAPDm__ph__data& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline BOOLEAN& sacch()
    {return field_sacch;}
  inline const BOOLEAN& sacch() const
    {return field_sacch;}
  inline INTEGER& sapi()
    {return field_sapi;}
  inline const INTEGER& sapi() const
    {return field_sapi;}
  inline LAPDm__Types::LapdmFrame& lapdm()
    {return field_lapdm;}
  inline const LAPDm__Types::LapdmFrame& lapdm() const
    {return field_lapdm;}
  inline int size_of() const
    {return 3;}
  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 LAPDm__ph__data_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
LAPDm__ph__data_template *list_value;
} value_list;
struct {
LAPDm__ph__data_template* precondition;
LAPDm__ph__data_template* implied_template;
} implication_;
dynmatch_struct<LAPDm__ph__data>* dyn_match;
};

void set_specific();
void copy_value(const LAPDm__ph__data& other_value);
void copy_template(const LAPDm__ph__data_template& other_value);

public:
LAPDm__ph__data_template();
LAPDm__ph__data_template(template_sel other_value);
LAPDm__ph__data_template(const LAPDm__ph__data& other_value);
LAPDm__ph__data_template(const OPTIONAL<LAPDm__ph__data>& other_value);
LAPDm__ph__data_template(LAPDm__ph__data_template* p_precondition, LAPDm__ph__data_template* p_implied_template);
LAPDm__ph__data_template(Dynamic_Match_Interface<LAPDm__ph__data>* p_dyn_match);
LAPDm__ph__data_template(const LAPDm__ph__data_template& other_value);
~LAPDm__ph__data_template();
LAPDm__ph__data_template& operator=(template_sel other_value);
LAPDm__ph__data_template& operator=(const LAPDm__ph__data& other_value);
LAPDm__ph__data_template& operator=(const OPTIONAL<LAPDm__ph__data>& other_value);
LAPDm__ph__data_template& operator=(const LAPDm__ph__data_template& other_value);
boolean match(const LAPDm__ph__data& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
LAPDm__ph__data valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
LAPDm__ph__data_template& list_item(unsigned int list_index) const;
BOOLEAN_template& sacch();
const BOOLEAN_template& sacch() const;
INTEGER_template& sapi();
const INTEGER_template& sapi() const;
LAPDm__Types::LapdmFrame_template& lapdm();
const LAPDm__Types::LapdmFrame_template& lapdm() const;
int size_of() const;
void log() const;
void log_match(const LAPDm__ph__data& 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;
};

class TBF__UL__establish__req {
  INTEGER field_tbf__nr;
  INTEGER field_ra;
public:
  TBF__UL__establish__req();
  TBF__UL__establish__req(const INTEGER& par_tbf__nr,
    const INTEGER& par_ra);
  TBF__UL__establish__req(const TBF__UL__establish__req& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  TBF__UL__establish__req& operator=(const TBF__UL__establish__req& other_value);
  boolean operator==(const TBF__UL__establish__req& other_value) const;
  inline boolean operator!=(const TBF__UL__establish__req& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& tbf__nr()
    {return field_tbf__nr;}
  inline const INTEGER& tbf__nr() const
    {return field_tbf__nr;}
  inline INTEGER& ra()
    {return field_ra;}
  inline const INTEGER& ra() const
    {return field_ra;}
  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 TBF__UL__establish__req_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
TBF__UL__establish__req_template *list_value;
} value_list;
struct {
TBF__UL__establish__req_template* precondition;
TBF__UL__establish__req_template* implied_template;
} implication_;
dynmatch_struct<TBF__UL__establish__req>* dyn_match;
};

void set_specific();
void copy_value(const TBF__UL__establish__req& other_value);
void copy_template(const TBF__UL__establish__req_template& other_value);

public:
TBF__UL__establish__req_template();
TBF__UL__establish__req_template(template_sel other_value);
TBF__UL__establish__req_template(const TBF__UL__establish__req& other_value);
TBF__UL__establish__req_template(const OPTIONAL<TBF__UL__establish__req>& other_value);
TBF__UL__establish__req_template(TBF__UL__establish__req_template* p_precondition, TBF__UL__establish__req_template* p_implied_template);
TBF__UL__establish__req_template(Dynamic_Match_Interface<TBF__UL__establish__req>* p_dyn_match);
TBF__UL__establish__req_template(const TBF__UL__establish__req_template& other_value);
~TBF__UL__establish__req_template();
TBF__UL__establish__req_template& operator=(template_sel other_value);
TBF__UL__establish__req_template& operator=(const TBF__UL__establish__req& other_value);
TBF__UL__establish__req_template& operator=(const OPTIONAL<TBF__UL__establish__req>& other_value);
TBF__UL__establish__req_template& operator=(const TBF__UL__establish__req_template& other_value);
boolean match(const TBF__UL__establish__req& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
TBF__UL__establish__req valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
TBF__UL__establish__req_template& list_item(unsigned int list_index) const;
INTEGER_template& tbf__nr();
const INTEGER_template& tbf__nr() const;
INTEGER_template& ra();
const INTEGER_template& ra() const;
int size_of() const;
void log() const;
void log_match(const TBF__UL__establish__req& 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;
};

class TBF__DL__establish__req {
  INTEGER field_tbf__nr;
  TbfPars field_pars;
public:
  TBF__DL__establish__req();
  TBF__DL__establish__req(const INTEGER& par_tbf__nr,
    const TbfPars& par_pars);
  TBF__DL__establish__req(const TBF__DL__establish__req& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  TBF__DL__establish__req& operator=(const TBF__DL__establish__req& other_value);
  boolean operator==(const TBF__DL__establish__req& other_value) const;
  inline boolean operator!=(const TBF__DL__establish__req& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& tbf__nr()
    {return field_tbf__nr;}
  inline const INTEGER& tbf__nr() const
    {return field_tbf__nr;}
  inline TbfPars& pars()
    {return field_pars;}
  inline const TbfPars& pars() const
    {return field_pars;}
  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 TBF__DL__establish__req_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
TBF__DL__establish__req_template *list_value;
} value_list;
struct {
TBF__DL__establish__req_template* precondition;
TBF__DL__establish__req_template* implied_template;
} implication_;
dynmatch_struct<TBF__DL__establish__req>* dyn_match;
};

void set_specific();
void copy_value(const TBF__DL__establish__req& other_value);
void copy_template(const TBF__DL__establish__req_template& other_value);

public:
TBF__DL__establish__req_template();
TBF__DL__establish__req_template(template_sel other_value);
TBF__DL__establish__req_template(const TBF__DL__establish__req& other_value);
TBF__DL__establish__req_template(const OPTIONAL<TBF__DL__establish__req>& other_value);
TBF__DL__establish__req_template(TBF__DL__establish__req_template* p_precondition, TBF__DL__establish__req_template* p_implied_template);
TBF__DL__establish__req_template(Dynamic_Match_Interface<TBF__DL__establish__req>* p_dyn_match);
TBF__DL__establish__req_template(const TBF__DL__establish__req_template& other_value);
~TBF__DL__establish__req_template();
TBF__DL__establish__req_template& operator=(template_sel other_value);
TBF__DL__establish__req_template& operator=(const TBF__DL__establish__req& other_value);
TBF__DL__establish__req_template& operator=(const OPTIONAL<TBF__DL__establish__req>& other_value);
TBF__DL__establish__req_template& operator=(const TBF__DL__establish__req_template& other_value);
boolean match(const TBF__DL__establish__req& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
TBF__DL__establish__req valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
TBF__DL__establish__req_template& list_item(unsigned int list_index) const;
INTEGER_template& tbf__nr();
const INTEGER_template& tbf__nr() const;
TbfPars_template& pars();
const TbfPars_template& pars() const;
int size_of() const;
void log() const;
void log_match(const TBF__DL__establish__req& 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;
};

class RLCMAC__ph__data__ind {
  GSM__Types::GprsCodingScheme field_cs;
  INTEGER field_ts__nr;
  INTEGER field_fn;
  RLCMAC__Types::RlcmacDlBlock field_block;
public:
  RLCMAC__ph__data__ind();
  RLCMAC__ph__data__ind(const GSM__Types::GprsCodingScheme& par_cs,
    const INTEGER& par_ts__nr,
    const INTEGER& par_fn,
    const RLCMAC__Types::RlcmacDlBlock& par_block);
  RLCMAC__ph__data__ind(const RLCMAC__ph__data__ind& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RLCMAC__ph__data__ind& operator=(const RLCMAC__ph__data__ind& other_value);
  boolean operator==(const RLCMAC__ph__data__ind& other_value) const;
  inline boolean operator!=(const RLCMAC__ph__data__ind& 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::GprsCodingScheme& cs()
    {return field_cs;}
  inline const GSM__Types::GprsCodingScheme& cs() const
    {return field_cs;}
  inline INTEGER& ts__nr()
    {return field_ts__nr;}
  inline const INTEGER& ts__nr() const
    {return field_ts__nr;}
  inline INTEGER& fn()
    {return field_fn;}
  inline const INTEGER& fn() const
    {return field_fn;}
  inline RLCMAC__Types::RlcmacDlBlock& block()
    {return field_block;}
  inline const RLCMAC__Types::RlcmacDlBlock& block() const
    {return field_block;}
  inline int size_of() const
    {return 4;}
  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 RLCMAC__ph__data__ind_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RLCMAC__ph__data__ind_template *list_value;
} value_list;
struct {
RLCMAC__ph__data__ind_template* precondition;
RLCMAC__ph__data__ind_template* implied_template;
} implication_;
dynmatch_struct<RLCMAC__ph__data__ind>* dyn_match;
};

void set_specific();
void copy_value(const RLCMAC__ph__data__ind& other_value);
void copy_template(const RLCMAC__ph__data__ind_template& other_value);

public:
RLCMAC__ph__data__ind_template();
RLCMAC__ph__data__ind_template(template_sel other_value);
RLCMAC__ph__data__ind_template(const RLCMAC__ph__data__ind& other_value);
RLCMAC__ph__data__ind_template(const OPTIONAL<RLCMAC__ph__data__ind>& other_value);
RLCMAC__ph__data__ind_template(RLCMAC__ph__data__ind_template* p_precondition, RLCMAC__ph__data__ind_template* p_implied_template);
RLCMAC__ph__data__ind_template(Dynamic_Match_Interface<RLCMAC__ph__data__ind>* p_dyn_match);
RLCMAC__ph__data__ind_template(const RLCMAC__ph__data__ind_template& other_value);
~RLCMAC__ph__data__ind_template();
RLCMAC__ph__data__ind_template& operator=(template_sel other_value);
RLCMAC__ph__data__ind_template& operator=(const RLCMAC__ph__data__ind& other_value);
RLCMAC__ph__data__ind_template& operator=(const OPTIONAL<RLCMAC__ph__data__ind>& other_value);
RLCMAC__ph__data__ind_template& operator=(const RLCMAC__ph__data__ind_template& other_value);
boolean match(const RLCMAC__ph__data__ind& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RLCMAC__ph__data__ind valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RLCMAC__ph__data__ind_template& list_item(unsigned int list_index) const;
GSM__Types::GprsCodingScheme_template& cs();
const GSM__Types::GprsCodingScheme_template& cs() const;
INTEGER_template& ts__nr();
const INTEGER_template& ts__nr() const;
INTEGER_template& fn();
const INTEGER_template& fn() const;
RLCMAC__Types::RlcmacDlBlock_template& block();
const RLCMAC__Types::RlcmacDlBlock_template& block() const;
int size_of() const;
void log() const;
void log_match(const RLCMAC__ph__data__ind& 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;
};

class RLCMAC__ph__data__req__dyn {
  INTEGER field_tbf__id;
  GSM__Types::GprsCodingScheme field_cs;
  RLCMAC__Types::RlcmacUlBlock field_block;
public:
  RLCMAC__ph__data__req__dyn();
  RLCMAC__ph__data__req__dyn(const INTEGER& par_tbf__id,
    const GSM__Types::GprsCodingScheme& par_cs,
    const RLCMAC__Types::RlcmacUlBlock& par_block);
  RLCMAC__ph__data__req__dyn(const RLCMAC__ph__data__req__dyn& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RLCMAC__ph__data__req__dyn& operator=(const RLCMAC__ph__data__req__dyn& other_value);
  boolean operator==(const RLCMAC__ph__data__req__dyn& other_value) const;
  inline boolean operator!=(const RLCMAC__ph__data__req__dyn& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& tbf__id()
    {return field_tbf__id;}
  inline const INTEGER& tbf__id() const
    {return field_tbf__id;}
  inline GSM__Types::GprsCodingScheme& cs()
    {return field_cs;}
  inline const GSM__Types::GprsCodingScheme& cs() const
    {return field_cs;}
  inline RLCMAC__Types::RlcmacUlBlock& block()
    {return field_block;}
  inline const RLCMAC__Types::RlcmacUlBlock& block() const
    {return field_block;}
  inline int size_of() const
    {return 3;}
  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 RLCMAC__ph__data__req__dyn_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RLCMAC__ph__data__req__dyn_template *list_value;
} value_list;
struct {
RLCMAC__ph__data__req__dyn_template* precondition;
RLCMAC__ph__data__req__dyn_template* implied_template;
} implication_;
dynmatch_struct<RLCMAC__ph__data__req__dyn>* dyn_match;
};

void set_specific();
void copy_value(const RLCMAC__ph__data__req__dyn& other_value);
void copy_template(const RLCMAC__ph__data__req__dyn_template& other_value);

public:
RLCMAC__ph__data__req__dyn_template();
RLCMAC__ph__data__req__dyn_template(template_sel other_value);
RLCMAC__ph__data__req__dyn_template(const RLCMAC__ph__data__req__dyn& other_value);
RLCMAC__ph__data__req__dyn_template(const OPTIONAL<RLCMAC__ph__data__req__dyn>& other_value);
RLCMAC__ph__data__req__dyn_template(RLCMAC__ph__data__req__dyn_template* p_precondition, RLCMAC__ph__data__req__dyn_template* p_implied_template);
RLCMAC__ph__data__req__dyn_template(Dynamic_Match_Interface<RLCMAC__ph__data__req__dyn>* p_dyn_match);
RLCMAC__ph__data__req__dyn_template(const RLCMAC__ph__data__req__dyn_template& other_value);
~RLCMAC__ph__data__req__dyn_template();
RLCMAC__ph__data__req__dyn_template& operator=(template_sel other_value);
RLCMAC__ph__data__req__dyn_template& operator=(const RLCMAC__ph__data__req__dyn& other_value);
RLCMAC__ph__data__req__dyn_template& operator=(const OPTIONAL<RLCMAC__ph__data__req__dyn>& other_value);
RLCMAC__ph__data__req__dyn_template& operator=(const RLCMAC__ph__data__req__dyn_template& other_value);
boolean match(const RLCMAC__ph__data__req__dyn& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RLCMAC__ph__data__req__dyn valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RLCMAC__ph__data__req__dyn_template& list_item(unsigned int list_index) const;
INTEGER_template& tbf__id();
const INTEGER_template& tbf__id() const;
GSM__Types::GprsCodingScheme_template& cs();
const GSM__Types::GprsCodingScheme_template& cs() const;
RLCMAC__Types::RlcmacUlBlock_template& block();
const RLCMAC__Types::RlcmacUlBlock_template& block() const;
int size_of() const;
void log() const;
void log_match(const RLCMAC__ph__data__req__dyn& 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;
};

class RLCMAC__ph__data__req__abs {
  INTEGER field_tbf__id;
  GSM__Types::GprsCodingScheme field_cs;
  INTEGER field_ts__nr;
  INTEGER field_fn;
  GSM__Types::GsmBandArfcn field_arfcn;
  RLCMAC__Types::RlcmacUlBlock field_block;
public:
  RLCMAC__ph__data__req__abs();
  RLCMAC__ph__data__req__abs(const INTEGER& par_tbf__id,
    const GSM__Types::GprsCodingScheme& par_cs,
    const INTEGER& par_ts__nr,
    const INTEGER& par_fn,
    const GSM__Types::GsmBandArfcn& par_arfcn,
    const RLCMAC__Types::RlcmacUlBlock& par_block);
  RLCMAC__ph__data__req__abs(const RLCMAC__ph__data__req__abs& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  RLCMAC__ph__data__req__abs& operator=(const RLCMAC__ph__data__req__abs& other_value);
  boolean operator==(const RLCMAC__ph__data__req__abs& other_value) const;
  inline boolean operator!=(const RLCMAC__ph__data__req__abs& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline INTEGER& tbf__id()
    {return field_tbf__id;}
  inline const INTEGER& tbf__id() const
    {return field_tbf__id;}
  inline GSM__Types::GprsCodingScheme& cs()
    {return field_cs;}
  inline const GSM__Types::GprsCodingScheme& cs() const
    {return field_cs;}
  inline INTEGER& ts__nr()
    {return field_ts__nr;}
  inline const INTEGER& ts__nr() const
    {return field_ts__nr;}
  inline INTEGER& fn()
    {return field_fn;}
  inline const INTEGER& fn() const
    {return field_fn;}
  inline GSM__Types::GsmBandArfcn& arfcn()
    {return field_arfcn;}
  inline const GSM__Types::GsmBandArfcn& arfcn() const
    {return field_arfcn;}
  inline RLCMAC__Types::RlcmacUlBlock& block()
    {return field_block;}
  inline const RLCMAC__Types::RlcmacUlBlock& block() const
    {return field_block;}
  inline int size_of() const
    {return 6;}
  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 RLCMAC__ph__data__req__abs_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
RLCMAC__ph__data__req__abs_template *list_value;
} value_list;
struct {
RLCMAC__ph__data__req__abs_template* precondition;
RLCMAC__ph__data__req__abs_template* implied_template;
} implication_;
dynmatch_struct<RLCMAC__ph__data__req__abs>* dyn_match;
};

void set_specific();
void copy_value(const RLCMAC__ph__data__req__abs& other_value);
void copy_template(const RLCMAC__ph__data__req__abs_template& other_value);

public:
RLCMAC__ph__data__req__abs_template();
RLCMAC__ph__data__req__abs_template(template_sel other_value);
RLCMAC__ph__data__req__abs_template(const RLCMAC__ph__data__req__abs& other_value);
RLCMAC__ph__data__req__abs_template(const OPTIONAL<RLCMAC__ph__data__req__abs>& other_value);
RLCMAC__ph__data__req__abs_template(RLCMAC__ph__data__req__abs_template* p_precondition, RLCMAC__ph__data__req__abs_template* p_implied_template);
RLCMAC__ph__data__req__abs_template(Dynamic_Match_Interface<RLCMAC__ph__data__req__abs>* p_dyn_match);
RLCMAC__ph__data__req__abs_template(const RLCMAC__ph__data__req__abs_template& other_value);
~RLCMAC__ph__data__req__abs_template();
RLCMAC__ph__data__req__abs_template& operator=(template_sel other_value);
RLCMAC__ph__data__req__abs_template& operator=(const RLCMAC__ph__data__req__abs& other_value);
RLCMAC__ph__data__req__abs_template& operator=(const OPTIONAL<RLCMAC__ph__data__req__abs>& other_value);
RLCMAC__ph__data__req__abs_template& operator=(const RLCMAC__ph__data__req__abs_template& other_value);
boolean match(const RLCMAC__ph__data__req__abs& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
RLCMAC__ph__data__req__abs valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
RLCMAC__ph__data__req__abs_template& list_item(unsigned int list_index) const;
INTEGER_template& tbf__id();
const INTEGER_template& tbf__id() const;
GSM__Types::GprsCodingScheme_template& cs();
const GSM__Types::GprsCodingScheme_template& cs() const;
INTEGER_template& ts__nr();
const INTEGER_template& ts__nr() const;
INTEGER_template& fn();
const INTEGER_template& fn() const;
GSM__Types::GsmBandArfcn_template& arfcn();
const GSM__Types::GsmBandArfcn_template& arfcn() const;
RLCMAC__Types::RlcmacUlBlock_template& block();
const RLCMAC__Types::RlcmacUlBlock_template& block() const;
int size_of() const;
void log() const;
void log_match(const RLCMAC__ph__data__req__abs& 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;
};

class RLCMAC__ph__data__req : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_dyn = 1, ALT_abs = 2 };
private:
union_selection_type union_selection;
union {
RLCMAC__ph__data__req__dyn *field_dyn;
RLCMAC__ph__data__req__abs *field_abs;
};
void copy_value(const RLCMAC__ph__data__req& other_value);

public:
RLCMAC__ph__data__req();
RLCMAC__ph__data__req(const RLCMAC__ph__data__req& other_value);
~RLCMAC__ph__data__req();
RLCMAC__ph__data__req& operator=(const RLCMAC__ph__data__req& other_value);
boolean operator==(const RLCMAC__ph__data__req& other_value) const;
inline boolean operator!=(const RLCMAC__ph__data__req& other_value) const { return !(*this == other_value); }
RLCMAC__ph__data__req__dyn& dyn();
const RLCMAC__ph__data__req__dyn& dyn() const;
RLCMAC__ph__data__req__abs& abs();
const RLCMAC__ph__data__req__abs& abs() const;
inline union_selection_type get_selection() const { return union_selection; }
boolean ischosen(union_selection_type checked_selection) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class RLCMAC__ph__data__req_template : public Base_Template {
union {
struct {
RLCMAC__ph__data__req::union_selection_type union_selection;
union {
RLCMAC__ph__data__req__dyn_template *field_dyn;
RLCMAC__ph__data__req__abs_template *field_abs;
};
} single_value;
struct {
unsigned int n_values;
RLCMAC__ph__data__req_template *list_value;
} value_list;
struct {
RLCMAC__ph__data__req_template* precondition;
RLCMAC__ph__data__req_template* implied_template;
} implication_;
dynmatch_struct<RLCMAC__ph__data__req>* dyn_match;
};
void copy_value(const RLCMAC__ph__data__req& other_value);

void copy_template(const RLCMAC__ph__data__req_template& other_value);

public:
RLCMAC__ph__data__req_template();
RLCMAC__ph__data__req_template(template_sel other_value);
RLCMAC__ph__data__req_template(const RLCMAC__ph__data__req& other_value);
RLCMAC__ph__data__req_template(const OPTIONAL<RLCMAC__ph__data__req>& other_value);
RLCMAC__ph__data__req_template(RLCMAC__ph__data__req_template* p_precondition, RLCMAC__ph__data__req_template* p_implied_template);
RLCMAC__ph__data__req_template(Dynamic_Match_Interface<RLCMAC__ph__data__req>* p_dyn_match);
RLCMAC__ph__data__req_template(const RLCMAC__ph__data__req_template& other_value);
~RLCMAC__ph__data__req_template();
void clean_up();
RLCMAC__ph__data__req_template& operator=(template_sel other_value);
RLCMAC__ph__data__req_template& operator=(const RLCMAC__ph__data__req& other_value);
RLCMAC__ph__data__req_template& operator=(const OPTIONAL<RLCMAC__ph__data__req>& other_value);
RLCMAC__ph__data__req_template& operator=(const RLCMAC__ph__data__req_template& other_value);
boolean match(const RLCMAC__ph__data__req& other_value, boolean legacy = FALSE) const;
boolean is_value() const;RLCMAC__ph__data__req valueof() const;
RLCMAC__ph__data__req_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
RLCMAC__ph__data__req__dyn_template& dyn();
const RLCMAC__ph__data__req__dyn_template& dyn() const;
RLCMAC__ph__data__req__abs_template& abs();
const RLCMAC__ph__data__req__abs_template& abs() const;
boolean ischosen(RLCMAC__ph__data__req::union_selection_type checked_selection) const;
void log() const;
void log_match(const RLCMAC__ph__data__req& 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);
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 LAPDm__SP__PT : public PORT {
enum msg_selection { MESSAGE_0, MESSAGE_1, MESSAGE_2, MESSAGE_3, MESSAGE_4, MESSAGE_5, MESSAGE_6, MESSAGE_7 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
BCCH__tune__req *message_0;
DCCH__establish__req *message_1;
DCCH__switch__req *message_2;
DCCH__release__req *message_3;
TBF__UL__establish__req *message_4;
TBF__DL__establish__req *message_5;
RLCMAC__ph__data__req *message_6;
LAPDm__ph__data *message_7;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
LAPDm__SP__PT(const char *par_port_name = NULL);
~LAPDm__SP__PT();
void send(const DCCH__establish__res& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__res& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__res& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__res_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__res_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__res_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__res& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__res& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__res& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__res_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__res_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__res_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__res& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__res& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__res& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__res_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__res_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__res_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__ind& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__ind& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__ind& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__ind_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__ind_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__ind_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
public:
alt_status receive(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const BCCH__tune__req_template& value_template, BCCH__tune__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const BCCH__tune__req_template& value_template, BCCH__tune__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const BCCH__tune__req_template& value_template, BCCH__tune__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const DCCH__establish__req_template& value_template, DCCH__establish__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const DCCH__establish__req_template& value_template, DCCH__establish__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const DCCH__establish__req_template& value_template, DCCH__establish__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const DCCH__switch__req_template& value_template, DCCH__switch__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const DCCH__switch__req_template& value_template, DCCH__switch__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const DCCH__switch__req_template& value_template, DCCH__switch__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const DCCH__release__req_template& value_template, DCCH__release__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const DCCH__release__req_template& value_template, DCCH__release__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const DCCH__release__req_template& value_template, DCCH__release__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const TBF__UL__establish__req_template& value_template, TBF__UL__establish__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const TBF__UL__establish__req_template& value_template, TBF__UL__establish__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const TBF__UL__establish__req_template& value_template, TBF__UL__establish__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const TBF__DL__establish__req_template& value_template, TBF__DL__establish__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const TBF__DL__establish__req_template& value_template, TBF__DL__establish__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const TBF__DL__establish__req_template& value_template, TBF__DL__establish__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const RLCMAC__ph__data__req_template& value_template, RLCMAC__ph__data__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const RLCMAC__ph__data__req_template& value_template, RLCMAC__ph__data__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const RLCMAC__ph__data__req_template& value_template, RLCMAC__ph__data__req *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const LAPDm__ph__data_template& value_template, LAPDm__ph__data *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const LAPDm__ph__data_template& value_template, LAPDm__ph__data *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const LAPDm__ph__data_template& value_template, LAPDm__ph__data *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const BCCH__tune__req& incoming_par, component sender_component);
void incoming_message(const DCCH__establish__req& incoming_par, component sender_component);
void incoming_message(const DCCH__switch__req& incoming_par, component sender_component);
void incoming_message(const DCCH__release__req& incoming_par, component sender_component);
void incoming_message(const TBF__UL__establish__req& incoming_par, component sender_component);
void incoming_message(const TBF__DL__establish__req& incoming_par, component sender_component);
void incoming_message(const RLCMAC__ph__data__req& incoming_par, component sender_component);
void incoming_message(const LAPDm__ph__data& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class LAPDm__PT : public PORT {
enum msg_selection { MESSAGE_0, MESSAGE_1, MESSAGE_2, MESSAGE_3, MESSAGE_4 };
struct msg_queue_item : public msg_queue_item_base {
msg_selection item_selection;
union {
DCCH__establish__res *message_0;
DCCH__switch__res *message_1;
TBF__UL__establish__res *message_2;
RLCMAC__ph__data__ind *message_3;
LAPDm__ph__data *message_4;
};
component sender_component;
};

void remove_msg_queue_head();
protected:
void clear_queue();
public:
LAPDm__PT(const char *par_port_name = NULL);
~LAPDm__PT();
void send(const BCCH__tune__req& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const BCCH__tune__req& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const BCCH__tune__req& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const BCCH__tune__req_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const BCCH__tune__req_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const BCCH__tune__req_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__req& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__req& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__req& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__req_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__req_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__establish__req_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__req& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__req& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__req& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__req_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__req_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__switch__req_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__release__req& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__release__req& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__release__req& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__release__req_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__release__req_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const DCCH__release__req_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__req& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__req& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__req& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__req_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__req_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const TBF__UL__establish__req_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const TBF__DL__establish__req& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const TBF__DL__establish__req& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const TBF__DL__establish__req& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const TBF__DL__establish__req_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const TBF__DL__establish__req_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const TBF__DL__establish__req_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__req& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__req& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__req& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__req_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__req_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const RLCMAC__ph__data__req_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data_template& send_par, const COMPONENT& destination_component, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data_template& send_par, size_t nof_components, const COMPONENT* destination_components, FLOAT* timestamp_redirect = NULL);
void send(const LAPDm__ph__data_template& send_par, boolean broadcast = FALSE, FLOAT* timestamp_redirect = NULL);
public:
alt_status receive(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const DCCH__establish__res_template& value_template, DCCH__establish__res *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const DCCH__establish__res_template& value_template, DCCH__establish__res *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const DCCH__establish__res_template& value_template, DCCH__establish__res *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const DCCH__switch__res_template& value_template, DCCH__switch__res *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const DCCH__switch__res_template& value_template, DCCH__switch__res *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const DCCH__switch__res_template& value_template, DCCH__switch__res *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const TBF__UL__establish__res_template& value_template, TBF__UL__establish__res *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const TBF__UL__establish__res_template& value_template, TBF__UL__establish__res *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const TBF__UL__establish__res_template& value_template, TBF__UL__establish__res *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const RLCMAC__ph__data__ind_template& value_template, RLCMAC__ph__data__ind *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const RLCMAC__ph__data__ind_template& value_template, RLCMAC__ph__data__ind *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const RLCMAC__ph__data__ind_template& value_template, RLCMAC__ph__data__ind *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status receive(const LAPDm__ph__data_template& value_template, LAPDm__ph__data *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status check_receive(const LAPDm__ph__data_template& value_template, LAPDm__ph__data *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
alt_status trigger(const LAPDm__ph__data_template& value_template, LAPDm__ph__data *value_redirect, const COMPONENT_template& sender_template, COMPONENT *sender_ptr, FLOAT* timestamp_redirect, Index_Redirect*);
private:
void incoming_message(const DCCH__establish__res& incoming_par, component sender_component);
void incoming_message(const DCCH__switch__res& incoming_par, component sender_component);
void incoming_message(const TBF__UL__establish__res& incoming_par, component sender_component);
void incoming_message(const RLCMAC__ph__data__ind& incoming_par, component sender_component);
void incoming_message(const LAPDm__ph__data& incoming_par, component sender_component);
protected:
boolean process_message(const char *message_type, Text_Buf& incoming_buf, component sender_component, OCTETSTRING& slider);
};

class ph__state__enum : public Base_Type { // enum
friend class ph__state__enum_template;
public:
enum enum_type { PH__STATE__NULL = 0, PH__STATE__BCH = 1, PH__STATE__SEARCHING__BCH = 2, PH__STATE__TUNING__DCH = 3, PH__STATE__DCH = 4, PH__STATE__TBF = 5, UNKNOWN_VALUE = 6, UNBOUND_VALUE = 7 };
private:
enum_type enum_value;

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

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

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const ph__state__enum& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const ph__state__enum& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const ph__state__enum& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const ph__state__enum& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const ph__state__enum& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const ph__state__enum& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const ph__state__enum& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
};

class ph__state__enum_template : public Base_Template {
union {
ph__state__enum::enum_type single_value;
struct {
unsigned int n_values;
ph__state__enum_template *list_value;
} value_list;
struct {
ph__state__enum_template* precondition;
ph__state__enum_template* implied_template;
} implication_;
dynmatch_struct<ph__state__enum>* dyn_match;
};

void copy_template(const ph__state__enum_template& other_value);

public:
ph__state__enum_template();
ph__state__enum_template(template_sel other_value);
ph__state__enum_template(int other_value);
ph__state__enum_template(ph__state__enum::enum_type other_value);
ph__state__enum_template(const ph__state__enum& other_value);
ph__state__enum_template(const OPTIONAL<ph__state__enum>& other_value);
ph__state__enum_template(ph__state__enum_template* p_precondition, ph__state__enum_template* p_implied_template);
ph__state__enum_template(Dynamic_Match_Interface<ph__state__enum>* p_dyn_match);
ph__state__enum_template(const ph__state__enum_template& other_value);
~ph__state__enum_template();

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

boolean match(ph__state__enum::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const ph__state__enum& other_value, boolean legacy = FALSE) const;
ph__state__enum::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
ph__state__enum_template& list_item(unsigned int list_index);
void log() const;
void log_match(const ph__state__enum& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class as__tbf__ul__est_Default : public Default_Base {
public:
as__tbf__ul__est_Default();
alt_status call_altstep(boolean first_alt_run);
};

class as__tbf__dl__est_Default : public Default_Base {
public:
as__tbf__dl__est_Default();
alt_status call_altstep(boolean first_alt_run);
};


/* Function prototypes */

extern boolean operator==(null_type null_value, const TbfParsPerTs& other_value);
inline boolean operator!=(null_type null_value, const TbfParsPerTs& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const DCCH__release__req& other_value);
inline boolean operator!=(null_type null_value, const DCCH__release__req& other_value) { return !(null_value == other_value); }
extern void LAPDmStart();
extern void start_LAPDmStart(const COMPONENT& component_reference);
extern void set__ph__state(const ph__state__enum& new__state);
extern void start_set__ph__state(const COMPONENT& component_reference, const ph__state__enum& new__state);
extern void f__init();
extern void start_f__init(const COMPONENT& component_reference);
extern void f__release__dcch();
extern void start_f__release__dcch(const COMPONENT& component_reference);
extern void f__tune__bcch(const GSM__Types::GsmBandArfcn& arfcn, const BOOLEAN& combined);
extern void start_f__tune__bcch(const COMPONENT& component_reference, const GSM__Types::GsmBandArfcn& arfcn, const BOOLEAN& combined);
extern void f__establish__dcch(const INTEGER& ra);
extern void start_f__establish__dcch(const COMPONENT& component_reference, const INTEGER& ra);
extern void f__switch__dcch(const DCCH__switch__req& sw__req);
extern void start_f__switch__dcch(const COMPONENT& component_reference, const DCCH__switch__req& sw__req);
extern TfiUsfArr f__TfiUsfArrInit();
extern void f__TfiUsfArrSet(TfiUsfArr& a, const INTEGER& idx, const INTEGER& tfi__usf);
extern RLCMAC__ph__data__req_template ts__PH__DATA__ABS(const INTEGER& tbf__id, const GSM__Types::GprsCodingScheme& , const INTEGER& ts, const INTEGER& fn, const GSM__Types::GsmBandArfcn& arfcn, const RLCMAC__Types::RlcmacUlBlock& block);
extern BOOLEAN f__establish__tbf(const INTEGER& ra);
extern void start_f__establish__tbf(const COMPONENT& component_reference, const INTEGER& ra);
extern void f__release__tbf();
extern void start_f__release__tbf(const COMPONENT& component_reference);
extern alt_status as__tbf__ul__est_instance(boolean first_alt_run);
extern void as__tbf__ul__est(boolean nodefault_modifier);
extern Default_Base *activate_as__tbf__ul__est();
extern alt_status as__tbf__dl__est_instance(boolean first_alt_run);
extern void as__tbf__dl__est(boolean nodefault_modifier);
extern Default_Base *activate_as__tbf__dl__est();
extern void f__init__tbf();
extern void start_f__init__tbf(const COMPONENT& component_reference);
extern void ScanEvents();
extern void start_ScanEvents(const COMPONENT& component_reference);
extern void pre_init_module();
extern void post_init_module();
extern boolean init_comp_type(const char *component_type, boolean init_base_comps);
extern boolean init_system_port(const char* component_type, const char* port_name);
extern boolean start_ptc_function(const char *function_name, Text_Buf& function_arguments);

/* Global variable declarations */

extern const TTCN_Typedescriptor_t TfiUsfArr_descr_;
extern const XERdescriptor_t TfiUsfArr_0_xer_;
extern const TTCN_OERdescriptor_t TfiUsfArr_0_oer_;
extern const TTCN_Typedescriptor_t TfiUsfArr_0_descr_;
extern UNIVERSAL_CHARSTRING TfiUsfArr_0_default_coding;
extern UNIVERSAL_CHARSTRING BCCH__tune__req_arfcn_default_coding;
extern const XERdescriptor_t BCCH__tune__req_combined__ccch_xer_;
extern const TTCN_OERdescriptor_t BCCH__tune__req_combined__ccch_oer_;
extern const TTCN_Typedescriptor_t BCCH__tune__req_combined__ccch_descr_;
extern const TTCN_Typedescriptor_t BCCH__tune__req_descr_;
extern const XERdescriptor_t DCCH__establish__req_ra_xer_;
extern const TTCN_OERdescriptor_t DCCH__establish__req_ra_oer_;
extern const TTCN_Typedescriptor_t DCCH__establish__req_ra_descr_;
extern UNIVERSAL_CHARSTRING DCCH__establish__req_ra_default_coding;
extern const TTCN_Typedescriptor_t DCCH__establish__req_descr_;
extern const TTCN_Typedescriptor_t DCCH__establish__res_descr_;
extern UNIVERSAL_CHARSTRING DCCH__establish__res_chan__desc_default_coding;
extern const XERdescriptor_t DCCH__establish__res_err_xer_;
extern const TTCN_Typedescriptor_t DCCH__establish__res_err_descr_;
extern UNIVERSAL_CHARSTRING DCCH__switch__req_chan__desc_default_coding;
extern const TTCN_Typedescriptor_t DCCH__switch__req_descr_;
extern UNIVERSAL_CHARSTRING DCCH__switch__req_ma_default_coding;
extern const TTCN_Typedescriptor_t DCCH__switch__res_descr_;
extern const XERdescriptor_t DCCH__switch__res_err_xer_;
extern const TTCN_Typedescriptor_t DCCH__switch__res_err_descr_;
extern const TTCN_Typedescriptor_t TfiList_descr_;
extern const XERdescriptor_t TfiList_0_xer_;
extern const TTCN_OERdescriptor_t TfiList_0_oer_;
extern const TTCN_Typedescriptor_t TfiList_0_descr_;
extern UNIVERSAL_CHARSTRING TfiList_0_default_coding;
extern const TTCN_Typedescriptor_t TbfPars_descr_;
extern const XERdescriptor_t TbfPars_arfcn_xer_;
extern const TTCN_OERdescriptor_t TbfPars_arfcn_oer_;
extern const TTCN_Typedescriptor_t TbfPars_arfcn_descr_;
extern UNIVERSAL_CHARSTRING TbfPars_arfcn_default_coding;
extern const TTCN_Typedescriptor_t TbfParsPerTs_descr_;
extern const TbfPars_template& t__TbfParsInit;
extern TbfPars_template template_t__TbfParsInit;
extern const TTCN_Typedescriptor_t TBF__UL__establish__res_descr_;
extern const XERdescriptor_t TBF__UL__establish__res_err_xer_;
extern const TTCN_Typedescriptor_t TBF__UL__establish__res_err_descr_;
extern const TTCN_Typedescriptor_t DCCH__release__req_descr_;
extern const XERdescriptor_t LAPDm__ph__data_sacch_xer_;
extern const TTCN_OERdescriptor_t LAPDm__ph__data_sacch_oer_;
extern const TTCN_Typedescriptor_t LAPDm__ph__data_sacch_descr_;
extern const XERdescriptor_t LAPDm__ph__data_sapi_xer_;
extern const TTCN_OERdescriptor_t LAPDm__ph__data_sapi_oer_;
extern const TTCN_Typedescriptor_t LAPDm__ph__data_sapi_descr_;
extern UNIVERSAL_CHARSTRING LAPDm__ph__data_sapi_default_coding;
extern UNIVERSAL_CHARSTRING LAPDm__ph__data_lapdm_default_coding;
extern const TTCN_Typedescriptor_t LAPDm__ph__data_descr_;
extern const XERdescriptor_t TbfNr_xer_;
extern const TTCN_Typedescriptor_t TbfNr_descr_;
extern const XERdescriptor_t TBF__UL__establish__req_tbf__nr_xer_;
extern const TTCN_OERdescriptor_t TBF__UL__establish__req_tbf__nr_oer_;
extern const TTCN_Typedescriptor_t TBF__UL__establish__req_tbf__nr_descr_;
extern const XERdescriptor_t TBF__UL__establish__req_ra_xer_;
extern const TTCN_OERdescriptor_t TBF__UL__establish__req_ra_oer_;
extern const TTCN_Typedescriptor_t TBF__UL__establish__req_ra_descr_;
extern UNIVERSAL_CHARSTRING TBF__UL__establish__req_ra_default_coding;
extern const TTCN_Typedescriptor_t TBF__UL__establish__req_descr_;
extern const XERdescriptor_t TBF__DL__establish__req_tbf__nr_xer_;
extern const TTCN_OERdescriptor_t TBF__DL__establish__req_tbf__nr_oer_;
extern const TTCN_Typedescriptor_t TBF__DL__establish__req_tbf__nr_descr_;
extern const TTCN_Typedescriptor_t TBF__DL__establish__req_descr_;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__ind_cs_default_coding;
extern const XERdescriptor_t RLCMAC__ph__data__ind_ts__nr_xer_;
extern const TTCN_OERdescriptor_t RLCMAC__ph__data__ind_ts__nr_oer_;
extern const TTCN_Typedescriptor_t RLCMAC__ph__data__ind_ts__nr_descr_;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__ind_ts__nr_default_coding;
extern const XERdescriptor_t RLCMAC__ph__data__ind_fn_xer_;
extern const TTCN_OERdescriptor_t RLCMAC__ph__data__ind_fn_oer_;
extern const TTCN_Typedescriptor_t RLCMAC__ph__data__ind_fn_descr_;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__ind_fn_default_coding;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__ind_block_default_coding;
extern const TTCN_Typedescriptor_t RLCMAC__ph__data__ind_descr_;
extern const XERdescriptor_t RLCMAC__ph__data__req__dyn_tbf__id_xer_;
extern const TTCN_OERdescriptor_t RLCMAC__ph__data__req__dyn_tbf__id_oer_;
extern const TTCN_Typedescriptor_t RLCMAC__ph__data__req__dyn_tbf__id_descr_;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__req__dyn_tbf__id_default_coding;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__req__dyn_cs_default_coding;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__req__dyn_block_default_coding;
extern const TTCN_Typedescriptor_t RLCMAC__ph__data__req__dyn_descr_;
extern const XERdescriptor_t RLCMAC__ph__data__req__abs_tbf__id_xer_;
extern const TTCN_OERdescriptor_t RLCMAC__ph__data__req__abs_tbf__id_oer_;
extern const TTCN_Typedescriptor_t RLCMAC__ph__data__req__abs_tbf__id_descr_;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__req__abs_tbf__id_default_coding;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__req__abs_cs_default_coding;
extern const XERdescriptor_t RLCMAC__ph__data__req__abs_ts__nr_xer_;
extern const TTCN_OERdescriptor_t RLCMAC__ph__data__req__abs_ts__nr_oer_;
extern const TTCN_Typedescriptor_t RLCMAC__ph__data__req__abs_ts__nr_descr_;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__req__abs_ts__nr_default_coding;
extern const XERdescriptor_t RLCMAC__ph__data__req__abs_fn_xer_;
extern const TTCN_OERdescriptor_t RLCMAC__ph__data__req__abs_fn_oer_;
extern const TTCN_Typedescriptor_t RLCMAC__ph__data__req__abs_fn_descr_;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__req__abs_fn_default_coding;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__req__abs_arfcn_default_coding;
extern UNIVERSAL_CHARSTRING RLCMAC__ph__data__req__abs_block_default_coding;
extern const TTCN_Typedescriptor_t RLCMAC__ph__data__req__abs_descr_;
extern const TTCN_Typedescriptor_t RLCMAC__ph__data__req_descr_;
extern const TTCN_Typedescriptor_t ph__state__enum_descr_;
extern const TTCN_Typedescriptor_t& lapdm__CT_descr_;
extern L1CTL__PortType::L1CTL__PT lapdm__CT_component_L1CTL;
extern LAPDm__SP__PT lapdm__CT_component_LAPDM__SP;
extern ph__state__enum lapdm__CT_component_ph__state;
extern GSM__RR__Types::ChannelDescription lapdm__CT_component_chan__desc;
extern INTEGER lapdm__CT_component_ms__power__lvl;
extern INTEGER lapdm__CT_component_timing__adv;
extern TbfParsPerTs lapdm__CT_component_g__tbf__ul;
extern TbfParsPerTs lapdm__CT_component_g__tbf__dl;
extern const OCTETSTRING os_0,
os_1;
extern const CHARSTRING cs_1,
cs_0,
cs_2;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif