5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
fix-cqi
master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7d2c1b636b'
${ noResults }
srsRAN_4G/lib/include/srslte/asn1/rrc/meascfg.h

6629 lines
214 KiB
C
Raw Normal View History Unescape Escape

change license header to agnostic version with hint to root LICENSE file
4 years ago
/**
update nr asn1 files, and asn1 tests
4 years ago
*
change license header to agnostic version with hint to root LICENSE file
4 years ago
* \section COPYRIGHT
update nr asn1 files, and asn1 tests
4 years ago
*
change license header to agnostic version with hint to root LICENSE file
4 years ago
* Copyright 2013-2020 Software Radio Systems Limited
update nr asn1 files, and asn1 tests
4 years ago
*
change license header to agnostic version with hint to root LICENSE file
4 years ago
* By using this file, you agree to the terms and conditions set
* forth in the LICENSE file which can be found at the top level of
* the distribution.
update nr asn1 files, and asn1 tests
4 years ago
*
*/
/*******************************************************************************
*
* 3GPP TS ASN1 RRC v15.11.0 (2020-09)
*
******************************************************************************/
#ifndef SRSASN1_RRC_MEASCFG_H
#define SRSASN1_RRC_MEASCFG_H
#include "common_ext.h"
#include "rr_common.h"
namespace asn1 {
namespace rrc {
/*******************************************************************************
* Struct Definitions
******************************************************************************/
// Q-OffsetRange ::= ENUMERATED
struct q_offset_range_opts {
enum options {
db_minus24,
db_minus22,
db_minus20,
db_minus18,
db_minus16,
db_minus14,
db_minus12,
db_minus10,
db_minus8,
db_minus6,
db_minus5,
db_minus4,
db_minus3,
db_minus2,
db_minus1,
db0,
db1,
db2,
db3,
db4,
db5,
db6,
db8,
db10,
db12,
db14,
db16,
db18,
db20,
db22,
db24,
nulltype
} value;
typedef int8_t number_type;
std::string to_string() const;
int8_t to_number() const;
};
typedef enumerated<q_offset_range_opts> q_offset_range_e;
// SecondaryPreRegistrationZoneIdListHRPD ::= SEQUENCE (SIZE (1..2)) OF INTEGER (0..255)
using secondary_pre_regist_zone_id_list_hrpd_l = bounded_array<uint16_t, 2>;
// SpeedStateScaleFactors ::= SEQUENCE
struct speed_state_scale_factors_s {
struct sf_medium_opts {
enum options { odot25, odot5, odot75, ldot0, nulltype } value;
typedef float number_type;
std::string to_string() const;
float to_number() const;
std::string to_number_string() const;
};
typedef enumerated<sf_medium_opts> sf_medium_e_;
struct sf_high_opts {
enum options { odot25, odot5, odot75, ldot0, nulltype } value;
typedef float number_type;
std::string to_string() const;
float to_number() const;
std::string to_number_string() const;
};
typedef enumerated<sf_high_opts> sf_high_e_;
// member variables
sf_medium_e_ sf_medium;
sf_high_e_ sf_high;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// BandIndicatorGERAN ::= ENUMERATED
struct band_ind_geran_opts {
enum options { dcs1800, pcs1900, nulltype } value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<band_ind_geran_opts> band_ind_geran_e;
// ExplicitListOfARFCNs ::= SEQUENCE (SIZE (0..31)) OF INTEGER (0..1023)
using explicit_list_of_arfcns_l = bounded_array<uint16_t, 31>;
// PreRegistrationInfoHRPD ::= SEQUENCE
struct pre_regist_info_hrpd_s {
bool pre_regist_zone_id_present = false;
bool secondary_pre_regist_zone_id_list_present = false;
bool pre_regist_allowed = false;
uint16_t pre_regist_zone_id = 0;
secondary_pre_regist_zone_id_list_hrpd_l secondary_pre_regist_zone_id_list;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// CarrierFreqsGERAN ::= SEQUENCE
struct carrier_freqs_geran_s {
struct following_arfcns_c_ {
struct equally_spaced_arfcns_s_ {
uint8_t arfcn_spacing = 1;
uint8_t nof_following_arfcns = 0;
};
struct types_opts {
enum options { explicit_list_of_arfcns, equally_spaced_arfcns, variable_bit_map_of_arfcns, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
following_arfcns_c_() = default;
following_arfcns_c_(const following_arfcns_c_& other);
following_arfcns_c_& operator=(const following_arfcns_c_& other);
~following_arfcns_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const following_arfcns_c_& other) const;
bool operator!=(const following_arfcns_c_& other) const { return not(*this == other); }
// getters
explicit_list_of_arfcns_l& explicit_list_of_arfcns()
{
assert_choice_type("explicitListOfARFCNs", type_.to_string(), "followingARFCNs");
return c.get<explicit_list_of_arfcns_l>();
}
equally_spaced_arfcns_s_& equally_spaced_arfcns()
{
assert_choice_type("equallySpacedARFCNs", type_.to_string(), "followingARFCNs");
return c.get<equally_spaced_arfcns_s_>();
}
bounded_octstring<1, 16>& variable_bit_map_of_arfcns()
{
assert_choice_type("variableBitMapOfARFCNs", type_.to_string(), "followingARFCNs");
return c.get<bounded_octstring<1, 16> >();
}
const explicit_list_of_arfcns_l& explicit_list_of_arfcns() const
{
assert_choice_type("explicitListOfARFCNs", type_.to_string(), "followingARFCNs");
return c.get<explicit_list_of_arfcns_l>();
}
const equally_spaced_arfcns_s_& equally_spaced_arfcns() const
{
assert_choice_type("equallySpacedARFCNs", type_.to_string(), "followingARFCNs");
return c.get<equally_spaced_arfcns_s_>();
}
const bounded_octstring<1, 16>& variable_bit_map_of_arfcns() const
{
assert_choice_type("variableBitMapOfARFCNs", type_.to_string(), "followingARFCNs");
return c.get<bounded_octstring<1, 16> >();
}
explicit_list_of_arfcns_l& set_explicit_list_of_arfcns()
{
set(types::explicit_list_of_arfcns);
return c.get<explicit_list_of_arfcns_l>();
}
equally_spaced_arfcns_s_& set_equally_spaced_arfcns()
{
set(types::equally_spaced_arfcns);
return c.get<equally_spaced_arfcns_s_>();
}
bounded_octstring<1, 16>& set_variable_bit_map_of_arfcns()
{
set(types::variable_bit_map_of_arfcns);
return c.get<bounded_octstring<1, 16> >();
}
private:
types type_;
choice_buffer_t<bounded_octstring<1, 16>, equally_spaced_arfcns_s_, explicit_list_of_arfcns_l> c;
void destroy_();
};
// member variables
uint16_t start_arfcn = 0;
band_ind_geran_e band_ind;
following_arfcns_c_ following_arfcns;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const carrier_freqs_geran_s& other) const;
bool operator!=(const carrier_freqs_geran_s& other) const { return not(*this == other); }
};
// CellReselectionSubPriority-r13 ::= ENUMERATED
struct cell_resel_sub_prio_r13_opts {
enum options { odot2, odot4, odot6, odot8, nulltype } value;
typedef float number_type;
std::string to_string() const;
float to_number() const;
std::string to_number_string() const;
};
typedef enumerated<cell_resel_sub_prio_r13_opts> cell_resel_sub_prio_r13_e;
// MTC-SSB-NR-r15 ::= SEQUENCE
struct mtc_ssb_nr_r15_s {
struct periodicity_and_offset_r15_c_ {
struct types_opts {
enum options { sf5_r15, sf10_r15, sf20_r15, sf40_r15, sf80_r15, sf160_r15, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<types_opts> types;
// choice methods
periodicity_and_offset_r15_c_() = default;
periodicity_and_offset_r15_c_(const periodicity_and_offset_r15_c_& other);
periodicity_and_offset_r15_c_& operator=(const periodicity_and_offset_r15_c_& other);
~periodicity_and_offset_r15_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const periodicity_and_offset_r15_c_& other) const;
bool operator!=(const periodicity_and_offset_r15_c_& other) const { return not(*this == other); }
// getters
uint8_t& sf5_r15()
{
assert_choice_type("sf5-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
uint8_t& sf10_r15()
{
assert_choice_type("sf10-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
uint8_t& sf20_r15()
{
assert_choice_type("sf20-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
uint8_t& sf40_r15()
{
assert_choice_type("sf40-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
uint8_t& sf80_r15()
{
assert_choice_type("sf80-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
uint8_t& sf160_r15()
{
assert_choice_type("sf160-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
const uint8_t& sf5_r15() const
{
assert_choice_type("sf5-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
const uint8_t& sf10_r15() const
{
assert_choice_type("sf10-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
const uint8_t& sf20_r15() const
{
assert_choice_type("sf20-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
const uint8_t& sf40_r15() const
{
assert_choice_type("sf40-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
const uint8_t& sf80_r15() const
{
assert_choice_type("sf80-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
const uint8_t& sf160_r15() const
{
assert_choice_type("sf160-r15", type_.to_string(), "periodicityAndOffset-r15");
return c.get<uint8_t>();
}
uint8_t& set_sf5_r15()
{
set(types::sf5_r15);
return c.get<uint8_t>();
}
uint8_t& set_sf10_r15()
{
set(types::sf10_r15);
return c.get<uint8_t>();
}
uint8_t& set_sf20_r15()
{
set(types::sf20_r15);
return c.get<uint8_t>();
}
uint8_t& set_sf40_r15()
{
set(types::sf40_r15);
return c.get<uint8_t>();
}
uint8_t& set_sf80_r15()
{
set(types::sf80_r15);
return c.get<uint8_t>();
}
uint8_t& set_sf160_r15()
{
set(types::sf160_r15);
return c.get<uint8_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
struct ssb_dur_r15_opts {
enum options { sf1, sf2, sf3, sf4, sf5, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<ssb_dur_r15_opts> ssb_dur_r15_e_;
// member variables
periodicity_and_offset_r15_c_ periodicity_and_offset_r15;
ssb_dur_r15_e_ ssb_dur_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const mtc_ssb_nr_r15_s& other) const;
bool operator!=(const mtc_ssb_nr_r15_s& other) const { return not(*this == other); }
};
// MultiBandInfoList-r11 ::= SEQUENCE (SIZE (1..8)) OF INTEGER (1..256)
using multi_band_info_list_r11_l = bounded_array<uint16_t, 8>;
// MultiFrequencyBandListNR-r15 ::= SEQUENCE (SIZE (1..32)) OF INTEGER (1..1024)
using multi_freq_band_list_nr_r15_l = bounded_array<uint16_t, 32>;
// SS-RSSI-Measurement-r15 ::= SEQUENCE
struct ss_rssi_meas_r15_s {
bounded_bitstring<1, 80> meas_slots_r15;
uint8_t end_symbol_r15 = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const ss_rssi_meas_r15_s& other) const;
bool operator!=(const ss_rssi_meas_r15_s& other) const { return not(*this == other); }
};
update RRC ASN1 to 2020-09 v15.11
4 years ago
// SSB-ToMeasure-r15 ::= CHOICE
struct ssb_to_measure_r15_c {
struct types_opts {
enum options { short_bitmap_r15, medium_bitmap_r15, long_bitmap_r15, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
ssb_to_measure_r15_c() = default;
ssb_to_measure_r15_c(const ssb_to_measure_r15_c& other);
ssb_to_measure_r15_c& operator=(const ssb_to_measure_r15_c& other);
~ssb_to_measure_r15_c() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const ssb_to_measure_r15_c& other) const;
bool operator!=(const ssb_to_measure_r15_c& other) const { return not(*this == other); }
// getters
fixed_bitstring<4>& short_bitmap_r15()
{
assert_choice_type("shortBitmap-r15", type_.to_string(), "SSB-ToMeasure-r15");
return c.get<fixed_bitstring<4> >();
}
fixed_bitstring<8>& medium_bitmap_r15()
{
assert_choice_type("mediumBitmap-r15", type_.to_string(), "SSB-ToMeasure-r15");
return c.get<fixed_bitstring<8> >();
}
fixed_bitstring<64>& long_bitmap_r15()
{
assert_choice_type("longBitmap-r15", type_.to_string(), "SSB-ToMeasure-r15");
return c.get<fixed_bitstring<64> >();
}
const fixed_bitstring<4>& short_bitmap_r15() const
{
assert_choice_type("shortBitmap-r15", type_.to_string(), "SSB-ToMeasure-r15");
return c.get<fixed_bitstring<4> >();
}
const fixed_bitstring<8>& medium_bitmap_r15() const
{
assert_choice_type("mediumBitmap-r15", type_.to_string(), "SSB-ToMeasure-r15");
return c.get<fixed_bitstring<8> >();
}
const fixed_bitstring<64>& long_bitmap_r15() const
{
assert_choice_type("longBitmap-r15", type_.to_string(), "SSB-ToMeasure-r15");
return c.get<fixed_bitstring<64> >();
}
fixed_bitstring<4>& set_short_bitmap_r15()
{
set(types::short_bitmap_r15);
return c.get<fixed_bitstring<4> >();
}
fixed_bitstring<8>& set_medium_bitmap_r15()
{
set(types::medium_bitmap_r15);
return c.get<fixed_bitstring<8> >();
}
fixed_bitstring<64>& set_long_bitmap_r15()
{
set(types::long_bitmap_r15);
return c.get<fixed_bitstring<64> >();
}
private:
types type_;
choice_buffer_t<fixed_bitstring<64> > c;
void destroy_();
};
update nr asn1 files, and asn1 tests
4 years ago
// ThresholdListNR-r15 ::= SEQUENCE
struct thres_list_nr_r15_s {
bool nr_rsrp_r15_present = false;
bool nr_rsrq_r15_present = false;
bool nr_sinr_r15_present = false;
uint8_t nr_rsrp_r15 = 0;
uint8_t nr_rsrq_r15 = 0;
uint8_t nr_sinr_r15 = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const thres_list_nr_r15_s& other) const;
bool operator!=(const thres_list_nr_r15_s& other) const { return not(*this == other); }
};
// MobilityStateParameters ::= SEQUENCE
struct mob_state_params_s {
struct t_eval_opts {
enum options { s30, s60, s120, s180, s240, spare3, spare2, spare1, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<t_eval_opts> t_eval_e_;
struct t_hyst_normal_opts {
enum options { s30, s60, s120, s180, s240, spare3, spare2, spare1, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<t_hyst_normal_opts> t_hyst_normal_e_;
// member variables
t_eval_e_ t_eval;
t_hyst_normal_e_ t_hyst_normal;
uint8_t n_cell_change_medium = 1;
uint8_t n_cell_change_high = 1;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// CarrierFreqCDMA2000 ::= SEQUENCE
struct carrier_freq_cdma2000_s {
bandclass_cdma2000_e band_class;
uint16_t arfcn = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const carrier_freq_cdma2000_s& other) const;
bool operator!=(const carrier_freq_cdma2000_s& other) const { return not(*this == other); }
};
// MeasCSI-RS-Config-r12 ::= SEQUENCE
struct meas_csi_rs_cfg_r12_s {
bool ext = false;
uint8_t meas_csi_rs_id_r12 = 1;
uint16_t pci_r12 = 0;
uint16_t scrambling_id_r12 = 0;
uint8_t res_cfg_r12 = 0;
uint8_t sf_offset_r12 = 0;
q_offset_range_e csi_rs_individual_offset_r12;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_csi_rs_cfg_r12_s& other) const;
bool operator!=(const meas_csi_rs_cfg_r12_s& other) const { return not(*this == other); }
};
// PhysCellIdRangeUTRA-FDD-r9 ::= SEQUENCE
struct pci_range_utra_fdd_r9_s {
bool range_r9_present = false;
uint16_t start_r9 = 0;
uint16_t range_r9 = 2;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const pci_range_utra_fdd_r9_s& other) const;
bool operator!=(const pci_range_utra_fdd_r9_s& other) const { return not(*this == other); }
};
// AltTTT-CellsToAddMod-r12 ::= SEQUENCE
struct alt_ttt_cells_to_add_mod_r12_s {
uint8_t cell_idx_r12 = 1;
pci_range_s pci_range_r12;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const alt_ttt_cells_to_add_mod_r12_s& other) const;
bool operator!=(const alt_ttt_cells_to_add_mod_r12_s& other) const { return not(*this == other); }
};
// BT-NameList-r15 ::= SEQUENCE (SIZE (1..4)) OF OCTET STRING (SIZE (1..248))
using bt_name_list_r15_l = bounded_array<bounded_octstring<1, 248>, 4>;
// BlackCellsToAddMod ::= SEQUENCE
struct black_cells_to_add_mod_s {
uint8_t cell_idx = 1;
pci_range_s pci_range;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const black_cells_to_add_mod_s& other) const;
bool operator!=(const black_cells_to_add_mod_s& other) const { return not(*this == other); }
};
// CellsToAddMod ::= SEQUENCE
struct cells_to_add_mod_s {
uint8_t cell_idx = 1;
uint16_t pci = 0;
q_offset_range_e cell_individual_offset;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const cells_to_add_mod_s& other) const;
bool operator!=(const cells_to_add_mod_s& other) const { return not(*this == other); }
};
// CellsToAddModCDMA2000 ::= SEQUENCE
struct cells_to_add_mod_cdma2000_s {
uint8_t cell_idx = 1;
uint16_t pci = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const cells_to_add_mod_cdma2000_s& other) const;
bool operator!=(const cells_to_add_mod_cdma2000_s& other) const { return not(*this == other); }
};
// CellsToAddModNR-r15 ::= SEQUENCE
struct cells_to_add_mod_nr_r15_s {
uint8_t cell_idx_r15 = 1;
uint16_t pci_r15 = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const cells_to_add_mod_nr_r15_s& other) const;
bool operator!=(const cells_to_add_mod_nr_r15_s& other) const { return not(*this == other); }
};
// CellsToAddModUTRA-FDD ::= SEQUENCE
struct cells_to_add_mod_utra_fdd_s {
uint8_t cell_idx = 1;
uint16_t pci = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const cells_to_add_mod_utra_fdd_s& other) const;
bool operator!=(const cells_to_add_mod_utra_fdd_s& other) const { return not(*this == other); }
};
// CellsToAddModUTRA-TDD ::= SEQUENCE
struct cells_to_add_mod_utra_tdd_s {
uint8_t cell_idx = 1;
uint8_t pci = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const cells_to_add_mod_utra_tdd_s& other) const;
bool operator!=(const cells_to_add_mod_utra_tdd_s& other) const { return not(*this == other); }
};
// MeasCSI-RS-ToAddModList-r12 ::= SEQUENCE (SIZE (1..96)) OF MeasCSI-RS-Config-r12
using meas_csi_rs_to_add_mod_list_r12_l = dyn_array<meas_csi_rs_cfg_r12_s>;
// MeasCSI-RS-ToRemoveList-r12 ::= SEQUENCE (SIZE (1..96)) OF INTEGER (1..96)
using meas_csi_rs_to_rem_list_r12_l = dyn_array<uint8_t>;
// MeasSubframeCellList-r10 ::= SEQUENCE (SIZE (1..32)) OF PhysCellIdRange
using meas_sf_cell_list_r10_l = dyn_array<pci_range_s>;
// PhysCellIdRangeUTRA-FDDList-r9 ::= SEQUENCE (SIZE (1..4)) OF PhysCellIdRangeUTRA-FDD-r9
using pci_range_utra_fdd_list_r9_l = dyn_array<pci_range_utra_fdd_r9_s>;
// WLAN-ChannelList-r13 ::= SEQUENCE (SIZE (1..16)) OF INTEGER (0..255)
using wlan_ch_list_r13_l = bounded_array<uint16_t, 16>;
// WLAN-NameList-r15 ::= SEQUENCE (SIZE (1..4)) OF OCTET STRING (SIZE (1..32))
using wlan_name_list_r15_l = bounded_array<bounded_octstring<1, 32>, 4>;
// WhiteCellsToAddMod-r13 ::= SEQUENCE
struct white_cells_to_add_mod_r13_s {
uint8_t cell_idx_r13 = 1;
pci_range_s pci_range_r13;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const white_cells_to_add_mod_r13_s& other) const;
bool operator!=(const white_cells_to_add_mod_r13_s& other) const { return not(*this == other); }
};
// AltTTT-CellsToAddModList-r12 ::= SEQUENCE (SIZE (1..32)) OF AltTTT-CellsToAddMod-r12
using alt_ttt_cells_to_add_mod_list_r12_l = dyn_array<alt_ttt_cells_to_add_mod_r12_s>;
// BT-NameListConfig-r15 ::= CHOICE
struct bt_name_list_cfg_r15_c {
typedef setup_e types;
// choice methods
bt_name_list_cfg_r15_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const bt_name_list_cfg_r15_c& other) const;
bool operator!=(const bt_name_list_cfg_r15_c& other) const { return not(*this == other); }
// getters
bt_name_list_r15_l& setup()
{
assert_choice_type("setup", type_.to_string(), "BT-NameListConfig-r15");
return c;
}
const bt_name_list_r15_l& setup() const
{
assert_choice_type("setup", type_.to_string(), "BT-NameListConfig-r15");
return c;
}
bt_name_list_r15_l& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
bt_name_list_r15_l c;
};
// BlackCellsToAddModList ::= SEQUENCE (SIZE (1..32)) OF BlackCellsToAddMod
using black_cells_to_add_mod_list_l = dyn_array<black_cells_to_add_mod_s>;
// CDMA2000-Type ::= ENUMERATED
struct cdma2000_type_opts {
enum options { type1_xrtt, type_hrpd, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<cdma2000_type_opts> cdma2000_type_e;
// CSG-AllowedReportingCells-r9 ::= SEQUENCE
struct csg_allowed_report_cells_r9_s {
bool pci_range_utra_fdd_list_r9_present = false;
pci_range_utra_fdd_list_r9_l pci_range_utra_fdd_list_r9;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const csg_allowed_report_cells_r9_s& other) const;
bool operator!=(const csg_allowed_report_cells_r9_s& other) const { return not(*this == other); }
};
// CellIndexList ::= SEQUENCE (SIZE (1..32)) OF INTEGER (1..32)
using cell_idx_list_l = bounded_array<uint8_t, 32>;
// CellsToAddModList ::= SEQUENCE (SIZE (1..32)) OF CellsToAddMod
using cells_to_add_mod_list_l = dyn_array<cells_to_add_mod_s>;
// CellsToAddModListCDMA2000 ::= SEQUENCE (SIZE (1..32)) OF CellsToAddModCDMA2000
using cells_to_add_mod_list_cdma2000_l = dyn_array<cells_to_add_mod_cdma2000_s>;
// CellsToAddModListNR-r15 ::= SEQUENCE (SIZE (1..32)) OF CellsToAddModNR-r15
using cells_to_add_mod_list_nr_r15_l = dyn_array<cells_to_add_mod_nr_r15_s>;
// CellsToAddModListUTRA-FDD ::= SEQUENCE (SIZE (1..32)) OF CellsToAddModUTRA-FDD
using cells_to_add_mod_list_utra_fdd_l = dyn_array<cells_to_add_mod_utra_fdd_s>;
// CellsToAddModListUTRA-TDD ::= SEQUENCE (SIZE (1..32)) OF CellsToAddModUTRA-TDD
using cells_to_add_mod_list_utra_tdd_l = dyn_array<cells_to_add_mod_utra_tdd_s>;
// MeasCycleSCell-r10 ::= ENUMERATED
struct meas_cycle_scell_r10_opts {
enum options { sf160, sf256, sf320, sf512, sf640, sf1024, sf1280, spare1, nulltype } value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<meas_cycle_scell_r10_opts> meas_cycle_scell_r10_e;
// MeasDS-Config-r12 ::= CHOICE
struct meas_ds_cfg_r12_c {
struct setup_s_ {
struct dmtc_period_offset_r12_c_ {
struct types_opts {
enum options { ms40_r12, ms80_r12, ms160_r12, /*...*/ nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<types_opts, true> types;
// choice methods
dmtc_period_offset_r12_c_() = default;
dmtc_period_offset_r12_c_(const dmtc_period_offset_r12_c_& other);
dmtc_period_offset_r12_c_& operator=(const dmtc_period_offset_r12_c_& other);
~dmtc_period_offset_r12_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const dmtc_period_offset_r12_c_& other) const;
bool operator!=(const dmtc_period_offset_r12_c_& other) const { return not(*this == other); }
// getters
uint8_t& ms40_r12()
{
assert_choice_type("ms40-r12", type_.to_string(), "dmtc-PeriodOffset-r12");
return c.get<uint8_t>();
}
uint8_t& ms80_r12()
{
assert_choice_type("ms80-r12", type_.to_string(), "dmtc-PeriodOffset-r12");
return c.get<uint8_t>();
}
uint8_t& ms160_r12()
{
assert_choice_type("ms160-r12", type_.to_string(), "dmtc-PeriodOffset-r12");
return c.get<uint8_t>();
}
const uint8_t& ms40_r12() const
{
assert_choice_type("ms40-r12", type_.to_string(), "dmtc-PeriodOffset-r12");
return c.get<uint8_t>();
}
const uint8_t& ms80_r12() const
{
assert_choice_type("ms80-r12", type_.to_string(), "dmtc-PeriodOffset-r12");
return c.get<uint8_t>();
}
const uint8_t& ms160_r12() const
{
assert_choice_type("ms160-r12", type_.to_string(), "dmtc-PeriodOffset-r12");
return c.get<uint8_t>();
}
uint8_t& set_ms40_r12()
{
set(types::ms40_r12);
return c.get<uint8_t>();
}
uint8_t& set_ms80_r12()
{
set(types::ms80_r12);
return c.get<uint8_t>();
}
uint8_t& set_ms160_r12()
{
set(types::ms160_r12);
return c.get<uint8_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
struct ds_occasion_dur_r12_c_ {
struct types_opts {
enum options { dur_fdd_r12, dur_tdd_r12, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
ds_occasion_dur_r12_c_() = default;
ds_occasion_dur_r12_c_(const ds_occasion_dur_r12_c_& other);
ds_occasion_dur_r12_c_& operator=(const ds_occasion_dur_r12_c_& other);
~ds_occasion_dur_r12_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const ds_occasion_dur_r12_c_& other) const;
bool operator!=(const ds_occasion_dur_r12_c_& other) const { return not(*this == other); }
// getters
uint8_t& dur_fdd_r12()
{
assert_choice_type("durationFDD-r12", type_.to_string(), "ds-OccasionDuration-r12");
return c.get<uint8_t>();
}
uint8_t& dur_tdd_r12()
{
assert_choice_type("durationTDD-r12", type_.to_string(), "ds-OccasionDuration-r12");
return c.get<uint8_t>();
}
const uint8_t& dur_fdd_r12() const
{
assert_choice_type("durationFDD-r12", type_.to_string(), "ds-OccasionDuration-r12");
return c.get<uint8_t>();
}
const uint8_t& dur_tdd_r12() const
{
assert_choice_type("durationTDD-r12", type_.to_string(), "ds-OccasionDuration-r12");
return c.get<uint8_t>();
}
uint8_t& set_dur_fdd_r12()
{
set(types::dur_fdd_r12);
return c.get<uint8_t>();
}
uint8_t& set_dur_tdd_r12()
{
set(types::dur_tdd_r12);
return c.get<uint8_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
// member variables
bool ext = false;
bool meas_csi_rs_to_rem_list_r12_present = false;
bool meas_csi_rs_to_add_mod_list_r12_present = false;
dmtc_period_offset_r12_c_ dmtc_period_offset_r12;
ds_occasion_dur_r12_c_ ds_occasion_dur_r12;
meas_csi_rs_to_rem_list_r12_l meas_csi_rs_to_rem_list_r12;
meas_csi_rs_to_add_mod_list_r12_l meas_csi_rs_to_add_mod_list_r12;
// ...
};
typedef setup_e types;
// choice methods
meas_ds_cfg_r12_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_ds_cfg_r12_c& other) const;
bool operator!=(const meas_ds_cfg_r12_c& other) const { return not(*this == other); }
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "MeasDS-Config-r12");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "MeasDS-Config-r12");
return c;
}
setup_s_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_s_ c;
};
// MeasGapConfig ::= CHOICE
struct meas_gap_cfg_c {
struct setup_s_ {
struct gap_offset_c_ {
struct types_opts {
enum options {
gp0,
gp1,
// ...
gp2_r14,
gp3_r14,
gp_ncsg0_r14,
gp_ncsg1_r14,
gp_ncsg2_r14,
gp_ncsg3_r14,
gp_non_uniform1_r14,
gp_non_uniform2_r14,
gp_non_uniform3_r14,
gp_non_uniform4_r14,
gp4_r15,
gp5_r15,
gp6_r15,
gp7_r15,
gp8_r15,
gp9_r15,
gp10_r15,
gp11_r15,
nulltype
} value;
std::string to_string() const;
};
typedef enumerated<types_opts, true, 18> types;
// choice methods
gap_offset_c_() = default;
gap_offset_c_(const gap_offset_c_& other);
gap_offset_c_& operator=(const gap_offset_c_& other);
~gap_offset_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
uint8_t& gp0()
{
assert_choice_type("gp0", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp1()
{
assert_choice_type("gp1", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp2_r14()
{
assert_choice_type("gp2-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp3_r14()
{
assert_choice_type("gp3-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp_ncsg0_r14()
{
assert_choice_type("gp-ncsg0-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp_ncsg1_r14()
{
assert_choice_type("gp-ncsg1-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp_ncsg2_r14()
{
assert_choice_type("gp-ncsg2-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp_ncsg3_r14()
{
assert_choice_type("gp-ncsg3-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint16_t& gp_non_uniform1_r14()
{
assert_choice_type("gp-nonUniform1-r14", type_.to_string(), "gapOffset");
return c.get<uint16_t>();
}
uint16_t& gp_non_uniform2_r14()
{
assert_choice_type("gp-nonUniform2-r14", type_.to_string(), "gapOffset");
return c.get<uint16_t>();
}
uint16_t& gp_non_uniform3_r14()
{
assert_choice_type("gp-nonUniform3-r14", type_.to_string(), "gapOffset");
return c.get<uint16_t>();
}
uint16_t& gp_non_uniform4_r14()
{
assert_choice_type("gp-nonUniform4-r14", type_.to_string(), "gapOffset");
return c.get<uint16_t>();
}
uint8_t& gp4_r15()
{
assert_choice_type("gp4-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp5_r15()
{
assert_choice_type("gp5-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp6_r15()
{
assert_choice_type("gp6-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp7_r15()
{
assert_choice_type("gp7-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp8_r15()
{
assert_choice_type("gp8-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp9_r15()
{
assert_choice_type("gp9-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp10_r15()
{
assert_choice_type("gp10-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& gp11_r15()
{
assert_choice_type("gp11-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp0() const
{
assert_choice_type("gp0", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp1() const
{
assert_choice_type("gp1", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp2_r14() const
{
assert_choice_type("gp2-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp3_r14() const
{
assert_choice_type("gp3-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp_ncsg0_r14() const
{
assert_choice_type("gp-ncsg0-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp_ncsg1_r14() const
{
assert_choice_type("gp-ncsg1-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp_ncsg2_r14() const
{
assert_choice_type("gp-ncsg2-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp_ncsg3_r14() const
{
assert_choice_type("gp-ncsg3-r14", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint16_t& gp_non_uniform1_r14() const
{
assert_choice_type("gp-nonUniform1-r14", type_.to_string(), "gapOffset");
return c.get<uint16_t>();
}
const uint16_t& gp_non_uniform2_r14() const
{
assert_choice_type("gp-nonUniform2-r14", type_.to_string(), "gapOffset");
return c.get<uint16_t>();
}
const uint16_t& gp_non_uniform3_r14() const
{
assert_choice_type("gp-nonUniform3-r14", type_.to_string(), "gapOffset");
return c.get<uint16_t>();
}
const uint16_t& gp_non_uniform4_r14() const
{
assert_choice_type("gp-nonUniform4-r14", type_.to_string(), "gapOffset");
return c.get<uint16_t>();
}
const uint8_t& gp4_r15() const
{
assert_choice_type("gp4-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp5_r15() const
{
assert_choice_type("gp5-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp6_r15() const
{
assert_choice_type("gp6-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp7_r15() const
{
assert_choice_type("gp7-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp8_r15() const
{
assert_choice_type("gp8-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp9_r15() const
{
assert_choice_type("gp9-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp10_r15() const
{
assert_choice_type("gp10-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
const uint8_t& gp11_r15() const
{
assert_choice_type("gp11-r15", type_.to_string(), "gapOffset");
return c.get<uint8_t>();
}
uint8_t& set_gp0()
{
set(types::gp0);
return c.get<uint8_t>();
}
uint8_t& set_gp1()
{
set(types::gp1);
return c.get<uint8_t>();
}
uint8_t& set_gp2_r14()
{
set(types::gp2_r14);
return c.get<uint8_t>();
}
uint8_t& set_gp3_r14()
{
set(types::gp3_r14);
return c.get<uint8_t>();
}
uint8_t& set_gp_ncsg0_r14()
{
set(types::gp_ncsg0_r14);
return c.get<uint8_t>();
}
uint8_t& set_gp_ncsg1_r14()
{
set(types::gp_ncsg1_r14);
return c.get<uint8_t>();
}
uint8_t& set_gp_ncsg2_r14()
{
set(types::gp_ncsg2_r14);
return c.get<uint8_t>();
}
uint8_t& set_gp_ncsg3_r14()
{
set(types::gp_ncsg3_r14);
return c.get<uint8_t>();
}
uint16_t& set_gp_non_uniform1_r14()
{
set(types::gp_non_uniform1_r14);
return c.get<uint16_t>();
}
uint16_t& set_gp_non_uniform2_r14()
{
set(types::gp_non_uniform2_r14);
return c.get<uint16_t>();
}
uint16_t& set_gp_non_uniform3_r14()
{
set(types::gp_non_uniform3_r14);
return c.get<uint16_t>();
}
uint16_t& set_gp_non_uniform4_r14()
{
set(types::gp_non_uniform4_r14);
return c.get<uint16_t>();
}
uint8_t& set_gp4_r15()
{
set(types::gp4_r15);
return c.get<uint8_t>();
}
uint8_t& set_gp5_r15()
{
set(types::gp5_r15);
return c.get<uint8_t>();
}
uint8_t& set_gp6_r15()
{
set(types::gp6_r15);
return c.get<uint8_t>();
}
uint8_t& set_gp7_r15()
{
set(types::gp7_r15);
return c.get<uint8_t>();
}
uint8_t& set_gp8_r15()
{
set(types::gp8_r15);
return c.get<uint8_t>();
}
uint8_t& set_gp9_r15()
{
set(types::gp9_r15);
return c.get<uint8_t>();
}
uint8_t& set_gp10_r15()
{
set(types::gp10_r15);
return c.get<uint8_t>();
}
uint8_t& set_gp11_r15()
{
set(types::gp11_r15);
return c.get<uint8_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
// member variables
gap_offset_c_ gap_offset;
};
typedef setup_e types;
// choice methods
meas_gap_cfg_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "MeasGapConfig");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "MeasGapConfig");
return c;
}
setup_s_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_s_ c;
};
// MeasRSSI-ReportConfig-r13 ::= SEQUENCE
struct meas_rssi_report_cfg_r13_s {
bool ch_occupancy_thres_r13_present = false;
uint8_t ch_occupancy_thres_r13 = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_rssi_report_cfg_r13_s& other) const;
bool operator!=(const meas_rssi_report_cfg_r13_s& other) const { return not(*this == other); }
};
// MeasSensing-Config-r15 ::= SEQUENCE
struct meas_sensing_cfg_r15_s {
struct sensing_periodicity_r15_opts {
enum options { ms20, ms50, ms100, ms200, ms300, ms400, ms500, ms600, ms700, ms800, ms900, ms1000, nulltype } value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<sensing_periodicity_r15_opts> sensing_periodicity_r15_e_;
// member variables
uint8_t sensing_subch_num_r15 = 1;
sensing_periodicity_r15_e_ sensing_periodicity_r15;
uint8_t sensing_resel_counter_r15 = 5;
uint8_t sensing_prio_r15 = 1;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_sensing_cfg_r15_s& other) const;
bool operator!=(const meas_sensing_cfg_r15_s& other) const { return not(*this == other); }
};
// MeasSubframePatternConfigNeigh-r10 ::= CHOICE
struct meas_sf_pattern_cfg_neigh_r10_c {
struct setup_s_ {
bool meas_sf_cell_list_r10_present = false;
meas_sf_pattern_r10_c meas_sf_pattern_neigh_r10;
meas_sf_cell_list_r10_l meas_sf_cell_list_r10;
};
typedef setup_e types;
// choice methods
meas_sf_pattern_cfg_neigh_r10_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_sf_pattern_cfg_neigh_r10_c& other) const;
bool operator!=(const meas_sf_pattern_cfg_neigh_r10_c& other) const { return not(*this == other); }
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "MeasSubframePatternConfigNeigh-r10");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "MeasSubframePatternConfigNeigh-r10");
return c;
}
setup_s_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_s_ c;
};
// PhysCellIdGERAN ::= SEQUENCE
struct pci_geran_s {
fixed_bitstring<3> network_colour_code;
fixed_bitstring<3> base_station_colour_code;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const pci_geran_s& other) const;
bool operator!=(const pci_geran_s& other) const { return not(*this == other); }
};
// QuantityConfigRS-NR-r15 ::= SEQUENCE
struct quant_cfg_rs_nr_r15_s {
bool filt_coeff_rsrp_r15_present = false;
bool filt_coeff_rsrq_r15_present = false;
bool filt_coef_sinr_r13_present = false;
filt_coef_e filt_coeff_rsrp_r15;
filt_coef_e filt_coeff_rsrq_r15;
filt_coef_e filt_coef_sinr_r13;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_rs_nr_r15_s& other) const;
bool operator!=(const quant_cfg_rs_nr_r15_s& other) const { return not(*this == other); }
};
// RMTC-Config-r13 ::= CHOICE
struct rmtc_cfg_r13_c {
struct setup_s_ {
struct rmtc_period_r13_opts {
enum options { ms40, ms80, ms160, ms320, ms640, nulltype } value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<rmtc_period_r13_opts> rmtc_period_r13_e_;
struct meas_dur_r13_opts {
enum options { sym1, sym14, sym28, sym42, sym70, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<meas_dur_r13_opts> meas_dur_r13_e_;
// member variables
bool ext = false;
bool rmtc_sf_offset_r13_present = false;
rmtc_period_r13_e_ rmtc_period_r13;
uint16_t rmtc_sf_offset_r13 = 0;
meas_dur_r13_e_ meas_dur_r13;
// ...
};
typedef setup_e types;
// choice methods
rmtc_cfg_r13_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const rmtc_cfg_r13_c& other) const;
bool operator!=(const rmtc_cfg_r13_c& other) const { return not(*this == other); }
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "RMTC-Config-r13");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "RMTC-Config-r13");
return c;
}
setup_s_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_s_ c;
};
// RS-ConfigSSB-NR-r15 ::= SEQUENCE
struct rs_cfg_ssb_nr_r15_s {
struct subcarrier_spacing_ssb_r15_opts {
enum options { khz15, khz30, khz120, khz240, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<subcarrier_spacing_ssb_r15_opts> subcarrier_spacing_ssb_r15_e_;
update RRC ASN1 to 2020-09 v15.11
4 years ago
struct ssb_to_measure_r15_c_ {
typedef setup_e types;
// choice methods
ssb_to_measure_r15_c_() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const ssb_to_measure_r15_c_& other) const;
bool operator!=(const ssb_to_measure_r15_c_& other) const { return not(*this == other); }
// getters
ssb_to_measure_r15_c& setup()
{
assert_choice_type("setup", type_.to_string(), "ssb-ToMeasure-r15");
return c;
}
const ssb_to_measure_r15_c& setup() const
{
assert_choice_type("setup", type_.to_string(), "ssb-ToMeasure-r15");
return c;
}
ssb_to_measure_r15_c& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
ssb_to_measure_r15_c c;
};
update nr asn1 files, and asn1 tests
4 years ago
// member variables
bool ext = false;
mtc_ssb_nr_r15_s meas_timing_cfg_r15;
subcarrier_spacing_ssb_r15_e_ subcarrier_spacing_ssb_r15;
// ...
update RRC ASN1 to 2020-09 v15.11
4 years ago
// group 0
copy_ptr<ssb_to_measure_r15_c_> ssb_to_measure_r15;
update nr asn1 files, and asn1 tests
4 years ago
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const rs_cfg_ssb_nr_r15_s& other) const;
bool operator!=(const rs_cfg_ssb_nr_r15_s& other) const { return not(*this == other); }
};
// RSRQ-RangeConfig-r12 ::= CHOICE
struct rsrq_range_cfg_r12_c {
typedef setup_e types;
// choice methods
rsrq_range_cfg_r12_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const rsrq_range_cfg_r12_c& other) const;
bool operator!=(const rsrq_range_cfg_r12_c& other) const { return not(*this == other); }
// getters
int8_t& setup()
{
assert_choice_type("setup", type_.to_string(), "RSRQ-RangeConfig-r12");
return c;
}
const int8_t& setup() const
{
assert_choice_type("setup", type_.to_string(), "RSRQ-RangeConfig-r12");
return c;
}
int8_t& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
int8_t c;
};
// ReportInterval ::= ENUMERATED
struct report_interv_opts {
enum options {
ms120,
ms240,
ms480,
ms640,
ms1024,
ms2048,
ms5120,
ms10240,
min1,
min6,
min12,
min30,
min60,
spare3,
spare2,
spare1,
nulltype
} value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<report_interv_opts> report_interv_e;
// ReportQuantityNR-r15 ::= SEQUENCE
struct report_quant_nr_r15_s {
bool ss_rsrp = false;
bool ss_rsrq = false;
bool ss_sinr = false;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const report_quant_nr_r15_s& other) const;
bool operator!=(const report_quant_nr_r15_s& other) const { return not(*this == other); }
};
// ReportQuantityWLAN-r13 ::= SEQUENCE
struct report_quant_wlan_r13_s {
bool ext = false;
bool band_request_wlan_r13_present = false;
bool carrier_info_request_wlan_r13_present = false;
bool available_admission_capacity_request_wlan_r13_present = false;
bool backhaul_dl_bw_request_wlan_r13_present = false;
bool backhaul_ul_bw_request_wlan_r13_present = false;
bool ch_utilization_request_wlan_r13_present = false;
bool station_count_request_wlan_r13_present = false;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const report_quant_wlan_r13_s& other) const;
bool operator!=(const report_quant_wlan_r13_s& other) const { return not(*this == other); }
};
// ThresholdEUTRA ::= CHOICE
struct thres_eutra_c {
struct types_opts {
enum options { thres_rsrp, thres_rsrq, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
thres_eutra_c() = default;
thres_eutra_c(const thres_eutra_c& other);
thres_eutra_c& operator=(const thres_eutra_c& other);
~thres_eutra_c() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const thres_eutra_c& other) const;
bool operator!=(const thres_eutra_c& other) const { return not(*this == other); }
// getters
uint8_t& thres_rsrp()
{
assert_choice_type("threshold-RSRP", type_.to_string(), "ThresholdEUTRA");
return c.get<uint8_t>();
}
uint8_t& thres_rsrq()
{
assert_choice_type("threshold-RSRQ", type_.to_string(), "ThresholdEUTRA");
return c.get<uint8_t>();
}
const uint8_t& thres_rsrp() const
{
assert_choice_type("threshold-RSRP", type_.to_string(), "ThresholdEUTRA");
return c.get<uint8_t>();
}
const uint8_t& thres_rsrq() const
{
assert_choice_type("threshold-RSRQ", type_.to_string(), "ThresholdEUTRA");
return c.get<uint8_t>();
}
uint8_t& set_thres_rsrp()
{
set(types::thres_rsrp);
return c.get<uint8_t>();
}
uint8_t& set_thres_rsrq()
{
set(types::thres_rsrq);
return c.get<uint8_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
// ThresholdNR-r15 ::= CHOICE
struct thres_nr_r15_c {
struct types_opts {
enum options { nr_rsrp_r15, nr_rsrq_r15, nr_sinr_r15, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
thres_nr_r15_c() = default;
thres_nr_r15_c(const thres_nr_r15_c& other);
thres_nr_r15_c& operator=(const thres_nr_r15_c& other);
~thres_nr_r15_c() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const thres_nr_r15_c& other) const;
bool operator!=(const thres_nr_r15_c& other) const { return not(*this == other); }
// getters
uint8_t& nr_rsrp_r15()
{
assert_choice_type("nr-RSRP-r15", type_.to_string(), "ThresholdNR-r15");
return c.get<uint8_t>();
}
uint8_t& nr_rsrq_r15()
{
assert_choice_type("nr-RSRQ-r15", type_.to_string(), "ThresholdNR-r15");
return c.get<uint8_t>();
}
uint8_t& nr_sinr_r15()
{
assert_choice_type("nr-SINR-r15", type_.to_string(), "ThresholdNR-r15");
return c.get<uint8_t>();
}
const uint8_t& nr_rsrp_r15() const
{
assert_choice_type("nr-RSRP-r15", type_.to_string(), "ThresholdNR-r15");
return c.get<uint8_t>();
}
const uint8_t& nr_rsrq_r15() const
{
assert_choice_type("nr-RSRQ-r15", type_.to_string(), "ThresholdNR-r15");
return c.get<uint8_t>();
}
const uint8_t& nr_sinr_r15() const
{
assert_choice_type("nr-SINR-r15", type_.to_string(), "ThresholdNR-r15");
return c.get<uint8_t>();
}
uint8_t& set_nr_rsrp_r15()
{
set(types::nr_rsrp_r15);
return c.get<uint8_t>();
}
uint8_t& set_nr_rsrq_r15()
{
set(types::nr_rsrq_r15);
return c.get<uint8_t>();
}
uint8_t& set_nr_sinr_r15()
{
set(types::nr_sinr_r15);
return c.get<uint8_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
// ThresholdUTRA ::= CHOICE
struct thres_utra_c {
struct types_opts {
enum options { utra_rscp, utra_ec_n0, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<types_opts> types;
// choice methods
thres_utra_c() = default;
thres_utra_c(const thres_utra_c& other);
thres_utra_c& operator=(const thres_utra_c& other);
~thres_utra_c() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const thres_utra_c& other) const;
bool operator!=(const thres_utra_c& other) const { return not(*this == other); }
// getters
int8_t& utra_rscp()
{
assert_choice_type("utra-RSCP", type_.to_string(), "ThresholdUTRA");
return c.get<int8_t>();
}
uint8_t& utra_ec_n0()
{
assert_choice_type("utra-EcN0", type_.to_string(), "ThresholdUTRA");
return c.get<uint8_t>();
}
const int8_t& utra_rscp() const
{
assert_choice_type("utra-RSCP", type_.to_string(), "ThresholdUTRA");
return c.get<int8_t>();
}
const uint8_t& utra_ec_n0() const
{
assert_choice_type("utra-EcN0", type_.to_string(), "ThresholdUTRA");
return c.get<uint8_t>();
}
int8_t& set_utra_rscp()
{
set(types::utra_rscp);
return c.get<int8_t>();
}
uint8_t& set_utra_ec_n0()
{
set(types::utra_ec_n0);
return c.get<uint8_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
// TimeToTrigger ::= ENUMERATED
struct time_to_trigger_opts {
enum options {
ms0,
ms40,
ms64,
ms80,
ms100,
ms128,
ms160,
ms256,
ms320,
ms480,
ms512,
ms640,
ms1024,
ms1280,
ms2560,
ms5120,
nulltype
} value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<time_to_trigger_opts> time_to_trigger_e;
// Tx-ResourcePoolMeasList-r14 ::= SEQUENCE (SIZE (1..72)) OF INTEGER (1..72)
using tx_res_pool_meas_list_r14_l = dyn_array<uint8_t>;
// UL-DelayConfig-r13 ::= CHOICE
struct ul_delay_cfg_r13_c {
struct setup_s_ {
struct delay_thres_r13_opts {
enum options {
ms30,
ms40,
ms50,
ms60,
ms70,
ms80,
ms90,
ms100,
ms150,
ms300,
ms500,
ms750,
spare4,
spare3,
spare2,
spare1,
nulltype
} value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<delay_thres_r13_opts> delay_thres_r13_e_;
// member variables
delay_thres_r13_e_ delay_thres_r13;
};
typedef setup_e types;
// choice methods
ul_delay_cfg_r13_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const ul_delay_cfg_r13_c& other) const;
bool operator!=(const ul_delay_cfg_r13_c& other) const { return not(*this == other); }
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "UL-DelayConfig-r13");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "UL-DelayConfig-r13");
return c;
}
setup_s_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_s_ c;
};
// WLAN-CarrierInfo-r13 ::= SEQUENCE
struct wlan_carrier_info_r13_s {
struct country_code_r13_opts {
enum options { united_states, europe, japan, global, /*...*/ nulltype } value;
std::string to_string() const;
};
typedef enumerated<country_code_r13_opts, true> country_code_r13_e_;
// member variables
bool ext = false;
bool operating_class_r13_present = false;
bool country_code_r13_present = false;
bool ch_nums_r13_present = false;
uint16_t operating_class_r13 = 0;
country_code_r13_e_ country_code_r13;
wlan_ch_list_r13_l ch_nums_r13;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const wlan_carrier_info_r13_s& other) const;
bool operator!=(const wlan_carrier_info_r13_s& other) const { return not(*this == other); }
};
update RRC ASN1 to 2020-09 v15.11
4 years ago
// WLAN-Id-List-r13 ::= SEQUENCE (SIZE (1..32)) OF WLAN-Identifiers-r12
using wlan_id_list_r13_l = dyn_array<wlan_ids_r12_s>;
update nr asn1 files, and asn1 tests
4 years ago
// WLAN-NameListConfig-r15 ::= CHOICE
struct wlan_name_list_cfg_r15_c {
typedef setup_e types;
// choice methods
wlan_name_list_cfg_r15_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const wlan_name_list_cfg_r15_c& other) const;
bool operator!=(const wlan_name_list_cfg_r15_c& other) const { return not(*this == other); }
// getters
wlan_name_list_r15_l& setup()
{
assert_choice_type("setup", type_.to_string(), "WLAN-NameListConfig-r15");
return c;
}
const wlan_name_list_r15_l& setup() const
{
assert_choice_type("setup", type_.to_string(), "WLAN-NameListConfig-r15");
return c;
}
wlan_name_list_r15_l& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
wlan_name_list_r15_l c;
};
// WhiteCellsToAddModList-r13 ::= SEQUENCE (SIZE (1..32)) OF WhiteCellsToAddMod-r13
using white_cells_to_add_mod_list_r13_l = dyn_array<white_cells_to_add_mod_r13_s>;
// MeasGapConfigPerCC-r14 ::= SEQUENCE
struct meas_gap_cfg_per_cc_r14_s {
uint8_t serv_cell_id_r14 = 0;
meas_gap_cfg_c meas_gap_cfg_cc_r14;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasObjectCDMA2000 ::= SEQUENCE
struct meas_obj_cdma2000_s {
bool ext = false;
bool search_win_size_present = false;
bool offset_freq_present = false;
bool cells_to_rem_list_present = false;
bool cells_to_add_mod_list_present = false;
bool cell_for_which_to_report_cgi_present = false;
cdma2000_type_e cdma2000_type;
carrier_freq_cdma2000_s carrier_freq;
uint8_t search_win_size = 0;
int8_t offset_freq = -15;
cell_idx_list_l cells_to_rem_list;
cells_to_add_mod_list_cdma2000_l cells_to_add_mod_list;
uint16_t cell_for_which_to_report_cgi = 0;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_obj_cdma2000_s& other) const;
bool operator!=(const meas_obj_cdma2000_s& other) const { return not(*this == other); }
};
// MeasObjectEUTRA ::= SEQUENCE
struct meas_obj_eutra_s {
struct t312_r12_c_ {
struct setup_opts {
enum options { ms0, ms50, ms100, ms200, ms300, ms400, ms500, ms1000, nulltype } value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<setup_opts> setup_e_;
typedef setup_e types;
// choice methods
t312_r12_c_() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const t312_r12_c_& other) const;
bool operator!=(const t312_r12_c_& other) const { return not(*this == other); }
// getters
setup_e_& setup()
{
assert_choice_type("setup", type_.to_string(), "t312-r12");
return c;
}
const setup_e_& setup() const
{
assert_choice_type("setup", type_.to_string(), "t312-r12");
return c;
}
setup_e_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_e_ c;
};
// member variables
bool ext = false;
bool offset_freq_present = false;
bool cells_to_rem_list_present = false;
bool cells_to_add_mod_list_present = false;
bool black_cells_to_rem_list_present = false;
bool black_cells_to_add_mod_list_present = false;
bool cell_for_which_to_report_cgi_present = false;
uint32_t carrier_freq = 0;
allowed_meas_bw_e allowed_meas_bw;
bool presence_ant_port1 = false;
fixed_bitstring<2> neigh_cell_cfg;
q_offset_range_e offset_freq;
cell_idx_list_l cells_to_rem_list;
cells_to_add_mod_list_l cells_to_add_mod_list;
cell_idx_list_l black_cells_to_rem_list;
black_cells_to_add_mod_list_l black_cells_to_add_mod_list;
uint16_t cell_for_which_to_report_cgi = 0;
// ...
// group 0
bool meas_cycle_scell_r10_present = false;
meas_cycle_scell_r10_e meas_cycle_scell_r10;
copy_ptr<meas_sf_pattern_cfg_neigh_r10_c> meas_sf_pattern_cfg_neigh_r10;
// group 1
bool wideband_rsrq_meas_r11_present = false;
bool wideband_rsrq_meas_r11 = false;
// group 2
bool reduced_meas_performance_r12_present = false;
copy_ptr<cell_idx_list_l> alt_ttt_cells_to_rem_list_r12;
copy_ptr<alt_ttt_cells_to_add_mod_list_r12_l> alt_ttt_cells_to_add_mod_list_r12;
copy_ptr<t312_r12_c_> t312_r12;
bool reduced_meas_performance_r12 = false;
copy_ptr<meas_ds_cfg_r12_c> meas_ds_cfg_r12;
// group 3
bool carrier_freq_r13_present = false;
copy_ptr<cell_idx_list_l> white_cells_to_rem_list_r13;
copy_ptr<white_cells_to_add_mod_list_r13_l> white_cells_to_add_mod_list_r13;
copy_ptr<rmtc_cfg_r13_c> rmtc_cfg_r13;
uint32_t carrier_freq_r13 = 65536;
// group 4
bool fembms_mixed_carrier_r14_present = false;
copy_ptr<tx_res_pool_meas_list_r14_l> tx_res_pool_to_rem_list_r14;
copy_ptr<tx_res_pool_meas_list_r14_l> tx_res_pool_to_add_list_r14;
bool fembms_mixed_carrier_r14 = false;
// group 5
copy_ptr<meas_sensing_cfg_r15_s> meas_sensing_cfg_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_obj_eutra_s& other) const;
bool operator!=(const meas_obj_eutra_s& other) const { return not(*this == other); }
};
// MeasObjectEUTRA-v9e0 ::= SEQUENCE
struct meas_obj_eutra_v9e0_s {
uint32_t carrier_freq_v9e0 = 65536;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasObjectGERAN ::= SEQUENCE
struct meas_obj_geran_s {
bool ext = false;
bool offset_freq_present = false;
bool ncc_permitted_present = false;
bool cell_for_which_to_report_cgi_present = false;
carrier_freqs_geran_s carrier_freqs;
int8_t offset_freq = -15;
fixed_bitstring<8> ncc_permitted;
pci_geran_s cell_for_which_to_report_cgi;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_obj_geran_s& other) const;
bool operator!=(const meas_obj_geran_s& other) const { return not(*this == other); }
};
// MeasObjectNR-r15 ::= SEQUENCE
struct meas_obj_nr_r15_s {
using cells_for_which_to_report_sftd_r15_l_ = bounded_array<uint16_t, 3>;
struct band_nr_r15_c_ {
typedef setup_e types;
// choice methods
band_nr_r15_c_() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const band_nr_r15_c_& other) const;
bool operator!=(const band_nr_r15_c_& other) const { return not(*this == other); }
// getters
uint16_t& setup()
{
assert_choice_type("setup", type_.to_string(), "bandNR-r15");
return c;
}
const uint16_t& setup() const
{
assert_choice_type("setup", type_.to_string(), "bandNR-r15");
return c;
}
uint16_t& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
uint16_t c;
};
// member variables
bool ext = false;
bool thresh_rs_idx_r15_present = false;
bool max_rs_idx_cell_qual_r15_present = false;
bool offset_freq_r15_present = false;
bool black_cells_to_rem_list_r15_present = false;
bool black_cells_to_add_mod_list_r15_present = false;
bool cells_for_which_to_report_sftd_r15_present = false;
uint32_t carrier_freq_r15 = 0;
rs_cfg_ssb_nr_r15_s rs_cfg_ssb_r15;
thres_list_nr_r15_s thresh_rs_idx_r15;
uint8_t max_rs_idx_cell_qual_r15 = 1;
int8_t offset_freq_r15 = -15;
cell_idx_list_l black_cells_to_rem_list_r15;
cells_to_add_mod_list_nr_r15_l black_cells_to_add_mod_list_r15;
uint8_t quant_cfg_set_r15 = 1;
cells_for_which_to_report_sftd_r15_l_ cells_for_which_to_report_sftd_r15;
// ...
// group 0
bool cell_for_which_to_report_cgi_r15_present = false;
bool derive_ssb_idx_from_cell_r15_present = false;
uint16_t cell_for_which_to_report_cgi_r15 = 0;
bool derive_ssb_idx_from_cell_r15 = false;
copy_ptr<ss_rssi_meas_r15_s> ss_rssi_meas_r15;
copy_ptr<band_nr_r15_c_> band_nr_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_obj_nr_r15_s& other) const;
bool operator!=(const meas_obj_nr_r15_s& other) const { return not(*this == other); }
};
// MeasObjectUTRA ::= SEQUENCE
struct meas_obj_utra_s {
struct cells_to_add_mod_list_c_ {
struct types_opts {
enum options { cells_to_add_mod_list_utra_fdd, cells_to_add_mod_list_utra_tdd, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
cells_to_add_mod_list_c_() = default;
cells_to_add_mod_list_c_(const cells_to_add_mod_list_c_& other);
cells_to_add_mod_list_c_& operator=(const cells_to_add_mod_list_c_& other);
~cells_to_add_mod_list_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const cells_to_add_mod_list_c_& other) const;
bool operator!=(const cells_to_add_mod_list_c_& other) const { return not(*this == other); }
// getters
cells_to_add_mod_list_utra_fdd_l& cells_to_add_mod_list_utra_fdd()
{
assert_choice_type("cellsToAddModListUTRA-FDD", type_.to_string(), "cellsToAddModList");
return c.get<cells_to_add_mod_list_utra_fdd_l>();
}
cells_to_add_mod_list_utra_tdd_l& cells_to_add_mod_list_utra_tdd()
{
assert_choice_type("cellsToAddModListUTRA-TDD", type_.to_string(), "cellsToAddModList");
return c.get<cells_to_add_mod_list_utra_tdd_l>();
}
const cells_to_add_mod_list_utra_fdd_l& cells_to_add_mod_list_utra_fdd() const
{
assert_choice_type("cellsToAddModListUTRA-FDD", type_.to_string(), "cellsToAddModList");
return c.get<cells_to_add_mod_list_utra_fdd_l>();
}
const cells_to_add_mod_list_utra_tdd_l& cells_to_add_mod_list_utra_tdd() const
{
assert_choice_type("cellsToAddModListUTRA-TDD", type_.to_string(), "cellsToAddModList");
return c.get<cells_to_add_mod_list_utra_tdd_l>();
}
cells_to_add_mod_list_utra_fdd_l& set_cells_to_add_mod_list_utra_fdd()
{
set(types::cells_to_add_mod_list_utra_fdd);
return c.get<cells_to_add_mod_list_utra_fdd_l>();
}
cells_to_add_mod_list_utra_tdd_l& set_cells_to_add_mod_list_utra_tdd()
{
set(types::cells_to_add_mod_list_utra_tdd);
return c.get<cells_to_add_mod_list_utra_tdd_l>();
}
private:
types type_;
choice_buffer_t<cells_to_add_mod_list_utra_fdd_l, cells_to_add_mod_list_utra_tdd_l> c;
void destroy_();
};
struct cell_for_which_to_report_cgi_c_ {
struct types_opts {
enum options { utra_fdd, utra_tdd, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
cell_for_which_to_report_cgi_c_() = default;
cell_for_which_to_report_cgi_c_(const cell_for_which_to_report_cgi_c_& other);
cell_for_which_to_report_cgi_c_& operator=(const cell_for_which_to_report_cgi_c_& other);
~cell_for_which_to_report_cgi_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const cell_for_which_to_report_cgi_c_& other) const;
bool operator!=(const cell_for_which_to_report_cgi_c_& other) const { return not(*this == other); }
// getters
uint16_t& utra_fdd()
{
assert_choice_type("utra-FDD", type_.to_string(), "cellForWhichToReportCGI");
return c.get<uint16_t>();
}
uint8_t& utra_tdd()
{
assert_choice_type("utra-TDD", type_.to_string(), "cellForWhichToReportCGI");
return c.get<uint8_t>();
}
const uint16_t& utra_fdd() const
{
assert_choice_type("utra-FDD", type_.to_string(), "cellForWhichToReportCGI");
return c.get<uint16_t>();
}
const uint8_t& utra_tdd() const
{
assert_choice_type("utra-TDD", type_.to_string(), "cellForWhichToReportCGI");
return c.get<uint8_t>();
}
uint16_t& set_utra_fdd()
{
set(types::utra_fdd);
return c.get<uint16_t>();
}
uint8_t& set_utra_tdd()
{
set(types::utra_tdd);
return c.get<uint8_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
// member variables
bool ext = false;
bool offset_freq_present = false;
bool cells_to_rem_list_present = false;
bool cells_to_add_mod_list_present = false;
bool cell_for_which_to_report_cgi_present = false;
uint16_t carrier_freq = 0;
int8_t offset_freq = -15;
cell_idx_list_l cells_to_rem_list;
cells_to_add_mod_list_c_ cells_to_add_mod_list;
cell_for_which_to_report_cgi_c_ cell_for_which_to_report_cgi;
// ...
// group 0
copy_ptr<csg_allowed_report_cells_r9_s> csg_allowed_report_cells_v930;
// group 1
bool reduced_meas_performance_r12_present = false;
bool reduced_meas_performance_r12 = false;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_obj_utra_s& other) const;
bool operator!=(const meas_obj_utra_s& other) const { return not(*this == other); }
};
// MeasObjectWLAN-r13 ::= SEQUENCE
struct meas_obj_wlan_r13_s {
struct carrier_freq_r13_c_ {
using band_ind_list_wlan_r13_l_ = bounded_array<wlan_band_ind_r13_e, 8>;
using carrier_info_list_wlan_r13_l_ = dyn_array<wlan_carrier_info_r13_s>;
struct types_opts {
enum options { band_ind_list_wlan_r13, carrier_info_list_wlan_r13, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
carrier_freq_r13_c_() = default;
carrier_freq_r13_c_(const carrier_freq_r13_c_& other);
carrier_freq_r13_c_& operator=(const carrier_freq_r13_c_& other);
~carrier_freq_r13_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const carrier_freq_r13_c_& other) const;
bool operator!=(const carrier_freq_r13_c_& other) const { return not(*this == other); }
// getters
band_ind_list_wlan_r13_l_& band_ind_list_wlan_r13()
{
assert_choice_type("bandIndicatorListWLAN-r13", type_.to_string(), "carrierFreq-r13");
return c.get<band_ind_list_wlan_r13_l_>();
}
carrier_info_list_wlan_r13_l_& carrier_info_list_wlan_r13()
{
assert_choice_type("carrierInfoListWLAN-r13", type_.to_string(), "carrierFreq-r13");
return c.get<carrier_info_list_wlan_r13_l_>();
}
const band_ind_list_wlan_r13_l_& band_ind_list_wlan_r13() const
{
assert_choice_type("bandIndicatorListWLAN-r13", type_.to_string(), "carrierFreq-r13");
return c.get<band_ind_list_wlan_r13_l_>();
}
const carrier_info_list_wlan_r13_l_& carrier_info_list_wlan_r13() const
{
assert_choice_type("carrierInfoListWLAN-r13", type_.to_string(), "carrierFreq-r13");
return c.get<carrier_info_list_wlan_r13_l_>();
}
band_ind_list_wlan_r13_l_& set_band_ind_list_wlan_r13()
{
set(types::band_ind_list_wlan_r13);
return c.get<band_ind_list_wlan_r13_l_>();
}
carrier_info_list_wlan_r13_l_& set_carrier_info_list_wlan_r13()
{
set(types::carrier_info_list_wlan_r13);
return c.get<carrier_info_list_wlan_r13_l_>();
}
private:
types type_;
choice_buffer_t<band_ind_list_wlan_r13_l_, carrier_info_list_wlan_r13_l_> c;
void destroy_();
};
// member variables
bool ext = false;
bool carrier_freq_r13_present = false;
bool wlan_to_add_mod_list_r13_present = false;
bool wlan_to_rem_list_r13_present = false;
carrier_freq_r13_c_ carrier_freq_r13;
wlan_id_list_r13_l wlan_to_add_mod_list_r13;
wlan_id_list_r13_l wlan_to_rem_list_r13;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_obj_wlan_r13_s& other) const;
bool operator!=(const meas_obj_wlan_r13_s& other) const { return not(*this == other); }
};
// QuantityConfigNR-r15 ::= SEQUENCE
struct quant_cfg_nr_r15_s {
bool meas_quant_rs_idx_nr_r15_present = false;
quant_cfg_rs_nr_r15_s meas_quant_cell_nr_r15;
quant_cfg_rs_nr_r15_s meas_quant_rs_idx_nr_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_nr_r15_s& other) const;
bool operator!=(const quant_cfg_nr_r15_s& other) const { return not(*this == other); }
};
struct eutra_event_s {
struct event_id_c_ {
struct event_a1_s_ {
thres_eutra_c a1_thres;
};
struct event_a2_s_ {
thres_eutra_c a2_thres;
};
struct event_a3_s_ {
int8_t a3_offset = -30;
bool report_on_leave = false;
};
struct event_a4_s_ {
thres_eutra_c a4_thres;
};
struct event_a5_s_ {
thres_eutra_c a5_thres1;
thres_eutra_c a5_thres2;
};
struct event_a6_r10_s_ {
int8_t a6_offset_r10 = -30;
bool a6_report_on_leave_r10 = false;
};
struct event_c1_r12_s_ {
uint8_t c1_thres_r12 = 0;
bool c1_report_on_leave_r12 = false;
};
struct event_c2_r12_s_ {
uint8_t c2_ref_csi_rs_r12 = 1;
int8_t c2_offset_r12 = -30;
bool c2_report_on_leave_r12 = false;
};
struct event_v1_r14_s_ {
uint8_t v1_thres_r14 = 0;
};
struct event_v2_r14_s_ {
uint8_t v2_thres_r14 = 0;
};
struct event_h1_r15_s_ {
update RRC ASN1 to 2020-09 v15.11
4 years ago
uint16_t h1_thres_offset_r15 = 0;
uint8_t h1_hysteresis_r15 = 1;
update nr asn1 files, and asn1 tests
4 years ago
};
struct event_h2_r15_s_ {
update RRC ASN1 to 2020-09 v15.11
4 years ago
uint16_t h2_thres_offset_r15 = 0;
uint8_t h2_hysteresis_r15 = 1;
update nr asn1 files, and asn1 tests
4 years ago
};
struct types_opts {
enum options {
event_a1,
event_a2,
event_a3,
event_a4,
event_a5,
// ...
event_a6_r10,
event_c1_r12,
event_c2_r12,
event_v1_r14,
event_v2_r14,
event_h1_r15,
event_h2_r15,
nulltype
} value;
std::string to_string() const;
};
typedef enumerated<types_opts, true, 7> types;
// choice methods
event_id_c_() = default;
event_id_c_(const event_id_c_& other);
event_id_c_& operator=(const event_id_c_& other);
~event_id_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const event_id_c_& other) const;
bool operator!=(const event_id_c_& other) const { return not(*this == other); }
// getters
event_a1_s_& event_a1()
{
assert_choice_type("eventA1", type_.to_string(), "eventId");
return c.get<event_a1_s_>();
}
event_a2_s_& event_a2()
{
assert_choice_type("eventA2", type_.to_string(), "eventId");
return c.get<event_a2_s_>();
}
event_a3_s_& event_a3()
{
assert_choice_type("eventA3", type_.to_string(), "eventId");
return c.get<event_a3_s_>();
}
event_a4_s_& event_a4()
{
assert_choice_type("eventA4", type_.to_string(), "eventId");
return c.get<event_a4_s_>();
}
event_a5_s_& event_a5()
{
assert_choice_type("eventA5", type_.to_string(), "eventId");
return c.get<event_a5_s_>();
}
event_a6_r10_s_& event_a6_r10()
{
assert_choice_type("eventA6-r10", type_.to_string(), "eventId");
return c.get<event_a6_r10_s_>();
}
event_c1_r12_s_& event_c1_r12()
{
assert_choice_type("eventC1-r12", type_.to_string(), "eventId");
return c.get<event_c1_r12_s_>();
}
event_c2_r12_s_& event_c2_r12()
{
assert_choice_type("eventC2-r12", type_.to_string(), "eventId");
return c.get<event_c2_r12_s_>();
}
event_v1_r14_s_& event_v1_r14()
{
assert_choice_type("eventV1-r14", type_.to_string(), "eventId");
return c.get<event_v1_r14_s_>();
}
event_v2_r14_s_& event_v2_r14()
{
assert_choice_type("eventV2-r14", type_.to_string(), "eventId");
return c.get<event_v2_r14_s_>();
}
event_h1_r15_s_& event_h1_r15()
{
assert_choice_type("eventH1-r15", type_.to_string(), "eventId");
return c.get<event_h1_r15_s_>();
}
event_h2_r15_s_& event_h2_r15()
{
assert_choice_type("eventH2-r15", type_.to_string(), "eventId");
return c.get<event_h2_r15_s_>();
}
const event_a1_s_& event_a1() const
{
assert_choice_type("eventA1", type_.to_string(), "eventId");
return c.get<event_a1_s_>();
}
const event_a2_s_& event_a2() const
{
assert_choice_type("eventA2", type_.to_string(), "eventId");
return c.get<event_a2_s_>();
}
const event_a3_s_& event_a3() const
{
assert_choice_type("eventA3", type_.to_string(), "eventId");
return c.get<event_a3_s_>();
}
const event_a4_s_& event_a4() const
{
assert_choice_type("eventA4", type_.to_string(), "eventId");
return c.get<event_a4_s_>();
}
const event_a5_s_& event_a5() const
{
assert_choice_type("eventA5", type_.to_string(), "eventId");
return c.get<event_a5_s_>();
}
const event_a6_r10_s_& event_a6_r10() const
{
assert_choice_type("eventA6-r10", type_.to_string(), "eventId");
return c.get<event_a6_r10_s_>();
}
const event_c1_r12_s_& event_c1_r12() const
{
assert_choice_type("eventC1-r12", type_.to_string(), "eventId");
return c.get<event_c1_r12_s_>();
}
const event_c2_r12_s_& event_c2_r12() const
{
assert_choice_type("eventC2-r12", type_.to_string(), "eventId");
return c.get<event_c2_r12_s_>();
}
const event_v1_r14_s_& event_v1_r14() const
{
assert_choice_type("eventV1-r14", type_.to_string(), "eventId");
return c.get<event_v1_r14_s_>();
}
const event_v2_r14_s_& event_v2_r14() const
{
assert_choice_type("eventV2-r14", type_.to_string(), "eventId");
return c.get<event_v2_r14_s_>();
}
const event_h1_r15_s_& event_h1_r15() const
{
assert_choice_type("eventH1-r15", type_.to_string(), "eventId");
return c.get<event_h1_r15_s_>();
}
const event_h2_r15_s_& event_h2_r15() const
{
assert_choice_type("eventH2-r15", type_.to_string(), "eventId");
return c.get<event_h2_r15_s_>();
}
event_a1_s_& set_event_a1()
{
set(types::event_a1);
return c.get<event_a1_s_>();
}
event_a2_s_& set_event_a2()
{
set(types::event_a2);
return c.get<event_a2_s_>();
}
event_a3_s_& set_event_a3()
{
set(types::event_a3);
return c.get<event_a3_s_>();
}
event_a4_s_& set_event_a4()
{
set(types::event_a4);
return c.get<event_a4_s_>();
}
event_a5_s_& set_event_a5()
{
set(types::event_a5);
return c.get<event_a5_s_>();
}
event_a6_r10_s_& set_event_a6_r10()
{
set(types::event_a6_r10);
return c.get<event_a6_r10_s_>();
}
event_c1_r12_s_& set_event_c1_r12()
{
set(types::event_c1_r12);
return c.get<event_c1_r12_s_>();
}
event_c2_r12_s_& set_event_c2_r12()
{
set(types::event_c2_r12);
return c.get<event_c2_r12_s_>();
}
event_v1_r14_s_& set_event_v1_r14()
{
set(types::event_v1_r14);
return c.get<event_v1_r14_s_>();
}
event_v2_r14_s_& set_event_v2_r14()
{
set(types::event_v2_r14);
return c.get<event_v2_r14_s_>();
}
event_h1_r15_s_& set_event_h1_r15()
{
set(types::event_h1_r15);
return c.get<event_h1_r15_s_>();
}
event_h2_r15_s_& set_event_h2_r15()
{
set(types::event_h2_r15);
return c.get<event_h2_r15_s_>();
}
private:
types type_;
choice_buffer_t<event_a1_s_,
event_a2_s_,
event_a3_s_,
event_a4_s_,
event_a5_s_,
event_a6_r10_s_,
event_c1_r12_s_,
event_c2_r12_s_,
event_h1_r15_s_,
event_h2_r15_s_,
event_v1_r14_s_,
event_v2_r14_s_>
c;
void destroy_();
};
// member variables
event_id_c_ event_id;
uint8_t hysteresis = 0;
time_to_trigger_e time_to_trigger;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const eutra_event_s& other) const;
bool operator!=(const eutra_event_s& other) const { return not(*this == other); }
};
// ReportConfigEUTRA ::= SEQUENCE
struct report_cfg_eutra_s {
struct trigger_type_c_ {
typedef eutra_event_s event_s_;
struct periodical_s_ {
struct purpose_opts {
enum options { report_strongest_cells, report_cgi, nulltype } value;
std::string to_string() const;
};
typedef enumerated<purpose_opts> purpose_e_;
// member variables
purpose_e_ purpose;
};
struct types_opts {
enum options { event, periodical, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
trigger_type_c_() = default;
trigger_type_c_(const trigger_type_c_& other);
trigger_type_c_& operator=(const trigger_type_c_& other);
~trigger_type_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const trigger_type_c_& other) const;
bool operator!=(const trigger_type_c_& other) const { return not(*this == other); }
// getters
event_s_& event()
{
assert_choice_type("event", type_.to_string(), "triggerType");
return c.get<event_s_>();
}
periodical_s_& periodical()
{
assert_choice_type("periodical", type_.to_string(), "triggerType");
return c.get<periodical_s_>();
}
const event_s_& event() const
{
assert_choice_type("event", type_.to_string(), "triggerType");
return c.get<event_s_>();
}
const periodical_s_& periodical() const
{
assert_choice_type("periodical", type_.to_string(), "triggerType");
return c.get<periodical_s_>();
}
event_s_& set_event()
{
set(types::event);
return c.get<event_s_>();
}
periodical_s_& set_periodical()
{
set(types::periodical);
return c.get<periodical_s_>();
}
private:
types type_;
choice_buffer_t<event_s_, periodical_s_> c;
void destroy_();
};
struct trigger_quant_opts {
enum options { rsrp, rsrq, nulltype } value;
std::string to_string() const;
};
typedef enumerated<trigger_quant_opts> trigger_quant_e_;
struct report_quant_opts {
enum options { same_as_trigger_quant, both, nulltype } value;
std::string to_string() const;
};
typedef enumerated<report_quant_opts> report_quant_e_;
struct report_amount_opts {
enum options { r1, r2, r4, r8, r16, r32, r64, infinity, nulltype } value;
typedef int8_t number_type;
std::string to_string() const;
int8_t to_number() const;
};
typedef enumerated<report_amount_opts> report_amount_e_;
struct alt_time_to_trigger_r12_c_ {
typedef setup_e types;
// choice methods
alt_time_to_trigger_r12_c_() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const alt_time_to_trigger_r12_c_& other) const;
bool operator!=(const alt_time_to_trigger_r12_c_& other) const { return not(*this == other); }
// getters
time_to_trigger_e& setup()
{
assert_choice_type("setup", type_.to_string(), "alternativeTimeToTrigger-r12");
return c;
}
const time_to_trigger_e& setup() const
{
assert_choice_type("setup", type_.to_string(), "alternativeTimeToTrigger-r12");
return c;
}
time_to_trigger_e& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
time_to_trigger_e c;
};
struct rs_sinr_cfg_r13_c_ {
struct setup_s_ {
struct report_quant_v1310_opts {
enum options { rsrp_andsinr, rsrq_andsinr, all, nulltype } value;
std::string to_string() const;
};
typedef enumerated<report_quant_v1310_opts> report_quant_v1310_e_;
// member variables
bool trigger_quant_v1310_present = false;
bool an_thres1_r13_present = false;
bool a5_thres2_r13_present = false;
uint8_t an_thres1_r13 = 0;
uint8_t a5_thres2_r13 = 0;
report_quant_v1310_e_ report_quant_v1310;
};
typedef setup_e types;
// choice methods
rs_sinr_cfg_r13_c_() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const rs_sinr_cfg_r13_c_& other) const;
bool operator!=(const rs_sinr_cfg_r13_c_& other) const { return not(*this == other); }
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "rs-sinr-Config-r13");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "rs-sinr-Config-r13");
return c;
}
setup_s_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_s_ c;
};
struct purpose_v1430_opts {
enum options { report_location, sidelink, spare2, spare1, nulltype } value;
std::string to_string() const;
};
typedef enumerated<purpose_v1430_opts> purpose_v1430_e_;
// member variables
bool ext = false;
trigger_type_c_ trigger_type;
trigger_quant_e_ trigger_quant;
report_quant_e_ report_quant;
uint8_t max_report_cells = 1;
report_interv_e report_interv;
report_amount_e_ report_amount;
// ...
// group 0
bool si_request_for_ho_r9_present = false;
bool ue_rx_tx_time_diff_periodical_r9_present = false;
// group 1
bool include_location_info_r10_present = false;
bool report_add_neigh_meas_r10_present = false;
// group 2
bool use_t312_r12_present = false;
bool use_ps_cell_r12_present = false;
bool report_strongest_csi_rss_r12_present = false;
bool report_crs_meas_r12_present = false;
bool trigger_quant_csi_rs_r12_present = false;
copy_ptr<alt_time_to_trigger_r12_c_> alt_time_to_trigger_r12;
bool use_t312_r12 = false;
bool use_ps_cell_r12 = false;
copy_ptr<rsrq_range_cfg_r12_c> an_thres1_v1250;
copy_ptr<rsrq_range_cfg_r12_c> a5_thres2_v1250;
bool report_strongest_csi_rss_r12 = false;
bool report_crs_meas_r12 = false;
bool trigger_quant_csi_rs_r12 = false;
// group 3
bool report_sstd_meas_r13_present = false;
bool use_white_cell_list_r13_present = false;
bool include_multi_band_info_r13_present = false;
bool report_sstd_meas_r13 = false;
copy_ptr<rs_sinr_cfg_r13_c_> rs_sinr_cfg_r13;
bool use_white_cell_list_r13 = false;
copy_ptr<meas_rssi_report_cfg_r13_s> meas_rssi_report_cfg_r13;
copy_ptr<ul_delay_cfg_r13_c> ul_delay_cfg_r13;
// group 4
bool ue_rx_tx_time_diff_periodical_tdd_r13_present = false;
bool ue_rx_tx_time_diff_periodical_tdd_r13 = false;
// group 5
bool purpose_v1430_present = false;
purpose_v1430_e_ purpose_v1430;
// group 6
bool max_report_rs_idx_r15_present = false;
uint8_t max_report_rs_idx_r15 = 0;
// group 7
bool purpose_r15_present = false;
bool nof_trigger_cells_r15_present = false;
bool a4_a5_report_on_leave_r15_present = false;
copy_ptr<bt_name_list_cfg_r15_c> include_bt_meas_r15;
copy_ptr<wlan_name_list_cfg_r15_c> include_wlan_meas_r15;
uint8_t nof_trigger_cells_r15 = 2;
bool a4_a5_report_on_leave_r15 = false;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const report_cfg_eutra_s& other) const;
bool operator!=(const report_cfg_eutra_s& other) const { return not(*this == other); }
};
// ReportConfigInterRAT ::= SEQUENCE
struct report_cfg_inter_rat_s {
struct trigger_type_c_ {
struct event_s_ {
struct event_id_c_ {
struct event_b1_s_ {
struct b1_thres_c_ {
struct types_opts {
enum options { b1_thres_utra, b1_thres_geran, b1_thres_cdma2000, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
b1_thres_c_() = default;
b1_thres_c_(const b1_thres_c_& other);
b1_thres_c_& operator=(const b1_thres_c_& other);
~b1_thres_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const b1_thres_c_& other) const;
bool operator!=(const b1_thres_c_& other) const { return not(*this == other); }
// getters
thres_utra_c& b1_thres_utra()
{
assert_choice_type("b1-ThresholdUTRA", type_.to_string(), "b1-Threshold");
return c.get<thres_utra_c>();
}
uint8_t& b1_thres_geran()
{
assert_choice_type("b1-ThresholdGERAN", type_.to_string(), "b1-Threshold");
return c.get<uint8_t>();
}
uint8_t& b1_thres_cdma2000()
{
assert_choice_type("b1-ThresholdCDMA2000", type_.to_string(), "b1-Threshold");
return c.get<uint8_t>();
}
const thres_utra_c& b1_thres_utra() const
{
assert_choice_type("b1-ThresholdUTRA", type_.to_string(), "b1-Threshold");
return c.get<thres_utra_c>();
}
const uint8_t& b1_thres_geran() const
{
assert_choice_type("b1-ThresholdGERAN", type_.to_string(), "b1-Threshold");
return c.get<uint8_t>();
}
const uint8_t& b1_thres_cdma2000() const
{
assert_choice_type("b1-ThresholdCDMA2000", type_.to_string(), "b1-Threshold");
return c.get<uint8_t>();
}
thres_utra_c& set_b1_thres_utra()
{
set(types::b1_thres_utra);
return c.get<thres_utra_c>();
}
uint8_t& set_b1_thres_geran()
{
set(types::b1_thres_geran);
return c.get<uint8_t>();
}
uint8_t& set_b1_thres_cdma2000()
{
set(types::b1_thres_cdma2000);
return c.get<uint8_t>();
}
private:
types type_;
choice_buffer_t<thres_utra_c> c;
void destroy_();
};
// member variables
b1_thres_c_ b1_thres;
};
struct event_b2_s_ {
struct b2_thres2_c_ {
struct types_opts {
enum options { b2_thres2_utra, b2_thres2_geran, b2_thres2_cdma2000, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
b2_thres2_c_() = default;
b2_thres2_c_(const b2_thres2_c_& other);
b2_thres2_c_& operator=(const b2_thres2_c_& other);
~b2_thres2_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const b2_thres2_c_& other) const;
bool operator!=(const b2_thres2_c_& other) const { return not(*this == other); }
// getters
thres_utra_c& b2_thres2_utra()
{
assert_choice_type("b2-Threshold2UTRA", type_.to_string(), "b2-Threshold2");
return c.get<thres_utra_c>();
}
uint8_t& b2_thres2_geran()
{
assert_choice_type("b2-Threshold2GERAN", type_.to_string(), "b2-Threshold2");
return c.get<uint8_t>();
}
uint8_t& b2_thres2_cdma2000()
{
assert_choice_type("b2-Threshold2CDMA2000", type_.to_string(), "b2-Threshold2");
return c.get<uint8_t>();
}
const thres_utra_c& b2_thres2_utra() const
{
assert_choice_type("b2-Threshold2UTRA", type_.to_string(), "b2-Threshold2");
return c.get<thres_utra_c>();
}
const uint8_t& b2_thres2_geran() const
{
assert_choice_type("b2-Threshold2GERAN", type_.to_string(), "b2-Threshold2");
return c.get<uint8_t>();
}
const uint8_t& b2_thres2_cdma2000() const
{
assert_choice_type("b2-Threshold2CDMA2000", type_.to_string(), "b2-Threshold2");
return c.get<uint8_t>();
}
thres_utra_c& set_b2_thres2_utra()
{
set(types::b2_thres2_utra);
return c.get<thres_utra_c>();
}
uint8_t& set_b2_thres2_geran()
{
set(types::b2_thres2_geran);
return c.get<uint8_t>();
}
uint8_t& set_b2_thres2_cdma2000()
{
set(types::b2_thres2_cdma2000);
return c.get<uint8_t>();
}
private:
types type_;
choice_buffer_t<thres_utra_c> c;
void destroy_();
};
// member variables
thres_eutra_c b2_thres1;
b2_thres2_c_ b2_thres2;
};
struct event_w1_r13_s_ {
uint8_t w1_thres_r13 = 0;
};
struct event_w2_r13_s_ {
uint8_t w2_thres1_r13 = 0;
uint8_t w2_thres2_r13 = 0;
};
struct event_w3_r13_s_ {
uint8_t w3_thres_r13 = 0;
};
struct event_b1_nr_r15_s_ {
thres_nr_r15_c b1_thres_nr_r15;
bool report_on_leave_r15 = false;
};
struct event_b2_nr_r15_s_ {
thres_eutra_c b2_thres1_r15;
thres_nr_r15_c b2_thres2_nr_r15;
bool report_on_leave_r15 = false;
};
struct types_opts {
enum options {
event_b1,
event_b2,
// ...
event_w1_r13,
event_w2_r13,
event_w3_r13,
event_b1_nr_r15,
event_b2_nr_r15,
nulltype
} value;
std::string to_string() const;
};
typedef enumerated<types_opts, true, 5> types;
// choice methods
event_id_c_() = default;
event_id_c_(const event_id_c_& other);
event_id_c_& operator=(const event_id_c_& other);
~event_id_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const event_id_c_& other) const;
bool operator!=(const event_id_c_& other) const { return not(*this == other); }
// getters
event_b1_s_& event_b1()
{
assert_choice_type("eventB1", type_.to_string(), "eventId");
return c.get<event_b1_s_>();
}
event_b2_s_& event_b2()
{
assert_choice_type("eventB2", type_.to_string(), "eventId");
return c.get<event_b2_s_>();
}
event_w1_r13_s_& event_w1_r13()
{
assert_choice_type("eventW1-r13", type_.to_string(), "eventId");
return c.get<event_w1_r13_s_>();
}
event_w2_r13_s_& event_w2_r13()
{
assert_choice_type("eventW2-r13", type_.to_string(), "eventId");
return c.get<event_w2_r13_s_>();
}
event_w3_r13_s_& event_w3_r13()
{
assert_choice_type("eventW3-r13", type_.to_string(), "eventId");
return c.get<event_w3_r13_s_>();
}
event_b1_nr_r15_s_& event_b1_nr_r15()
{
assert_choice_type("eventB1-NR-r15", type_.to_string(), "eventId");
return c.get<event_b1_nr_r15_s_>();
}
event_b2_nr_r15_s_& event_b2_nr_r15()
{
assert_choice_type("eventB2-NR-r15", type_.to_string(), "eventId");
return c.get<event_b2_nr_r15_s_>();
}
const event_b1_s_& event_b1() const
{
assert_choice_type("eventB1", type_.to_string(), "eventId");
return c.get<event_b1_s_>();
}
const event_b2_s_& event_b2() const
{
assert_choice_type("eventB2", type_.to_string(), "eventId");
return c.get<event_b2_s_>();
}
const event_w1_r13_s_& event_w1_r13() const
{
assert_choice_type("eventW1-r13", type_.to_string(), "eventId");
return c.get<event_w1_r13_s_>();
}
const event_w2_r13_s_& event_w2_r13() const
{
assert_choice_type("eventW2-r13", type_.to_string(), "eventId");
return c.get<event_w2_r13_s_>();
}
const event_w3_r13_s_& event_w3_r13() const
{
assert_choice_type("eventW3-r13", type_.to_string(), "eventId");
return c.get<event_w3_r13_s_>();
}
const event_b1_nr_r15_s_& event_b1_nr_r15() const
{
assert_choice_type("eventB1-NR-r15", type_.to_string(), "eventId");
return c.get<event_b1_nr_r15_s_>();
}
const event_b2_nr_r15_s_& event_b2_nr_r15() const
{
assert_choice_type("eventB2-NR-r15", type_.to_string(), "eventId");
return c.get<event_b2_nr_r15_s_>();
}
event_b1_s_& set_event_b1()
{
set(types::event_b1);
return c.get<event_b1_s_>();
}
event_b2_s_& set_event_b2()
{
set(types::event_b2);
return c.get<event_b2_s_>();
}
event_w1_r13_s_& set_event_w1_r13()
{
set(types::event_w1_r13);
return c.get<event_w1_r13_s_>();
}
event_w2_r13_s_& set_event_w2_r13()
{
set(types::event_w2_r13);
return c.get<event_w2_r13_s_>();
}
event_w3_r13_s_& set_event_w3_r13()
{
set(types::event_w3_r13);
return c.get<event_w3_r13_s_>();
}
event_b1_nr_r15_s_& set_event_b1_nr_r15()
{
set(types::event_b1_nr_r15);
return c.get<event_b1_nr_r15_s_>();
}
event_b2_nr_r15_s_& set_event_b2_nr_r15()
{
set(types::event_b2_nr_r15);
return c.get<event_b2_nr_r15_s_>();
}
private:
types type_;
choice_buffer_t<event_b1_nr_r15_s_,
event_b1_s_,
event_b2_nr_r15_s_,
event_b2_s_,
event_w1_r13_s_,
event_w2_r13_s_,
event_w3_r13_s_>
c;
void destroy_();
};
// member variables
event_id_c_ event_id;
uint8_t hysteresis = 0;
time_to_trigger_e time_to_trigger;
};
struct periodical_s_ {
struct purpose_opts {
enum options { report_strongest_cells, report_strongest_cells_for_son, report_cgi, nulltype } value;
std::string to_string() const;
};
typedef enumerated<purpose_opts> purpose_e_;
// member variables
purpose_e_ purpose;
};
struct types_opts {
enum options { event, periodical, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
trigger_type_c_() = default;
trigger_type_c_(const trigger_type_c_& other);
trigger_type_c_& operator=(const trigger_type_c_& other);
~trigger_type_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const trigger_type_c_& other) const;
bool operator!=(const trigger_type_c_& other) const { return not(*this == other); }
// getters
event_s_& event()
{
assert_choice_type("event", type_.to_string(), "triggerType");
return c.get<event_s_>();
}
periodical_s_& periodical()
{
assert_choice_type("periodical", type_.to_string(), "triggerType");
return c.get<periodical_s_>();
}
const event_s_& event() const
{
assert_choice_type("event", type_.to_string(), "triggerType");
return c.get<event_s_>();
}
const periodical_s_& periodical() const
{
assert_choice_type("periodical", type_.to_string(), "triggerType");
return c.get<periodical_s_>();
}
event_s_& set_event()
{
set(types::event);
return c.get<event_s_>();
}
periodical_s_& set_periodical()
{
set(types::periodical);
return c.get<periodical_s_>();
}
private:
types type_;
choice_buffer_t<event_s_, periodical_s_> c;
void destroy_();
};
struct report_amount_opts {
enum options { r1, r2, r4, r8, r16, r32, r64, infinity, nulltype } value;
typedef int8_t number_type;
std::string to_string() const;
int8_t to_number() const;
};
typedef enumerated<report_amount_opts> report_amount_e_;
struct b2_thres1_v1250_c_ {
typedef setup_e types;
// choice methods
b2_thres1_v1250_c_() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const b2_thres1_v1250_c_& other) const;
bool operator!=(const b2_thres1_v1250_c_& other) const { return not(*this == other); }
// getters
int8_t& setup()
{
assert_choice_type("setup", type_.to_string(), "b2-Threshold1-v1250");
return c;
}
const int8_t& setup() const
{
assert_choice_type("setup", type_.to_string(), "b2-Threshold1-v1250");
return c;
}
int8_t& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
int8_t c;
};
struct report_sftd_meas_r15_opts {
enum options { pscell, neighbor_cells, nulltype } value;
std::string to_string() const;
};
typedef enumerated<report_sftd_meas_r15_opts> report_sftd_meas_r15_e_;
// member variables
bool ext = false;
trigger_type_c_ trigger_type;
uint8_t max_report_cells = 1;
report_interv_e report_interv;
report_amount_e_ report_amount;
// ...
// group 0
bool si_request_for_ho_r9_present = false;
// group 1
bool report_quant_utra_fdd_r10_present = false;
// group 2
bool include_location_info_r11_present = false;
bool include_location_info_r11 = false;
// group 3
copy_ptr<b2_thres1_v1250_c_> b2_thres1_v1250;
// group 4
copy_ptr<report_quant_wlan_r13_s> report_quant_wlan_r13;
// group 5
bool report_any_wlan_r14_present = false;
bool report_any_wlan_r14 = false;
// group 6
bool max_report_rs_idx_r15_present = false;
bool report_rs_idx_results_nr_present = false;
bool report_sftd_meas_r15_present = false;
copy_ptr<report_quant_nr_r15_s> report_quant_cell_nr_r15;
uint8_t max_report_rs_idx_r15 = 0;
copy_ptr<report_quant_nr_r15_s> report_quant_rs_idx_nr_r15;
bool report_rs_idx_results_nr = false;
report_sftd_meas_r15_e_ report_sftd_meas_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const report_cfg_inter_rat_s& other) const;
bool operator!=(const report_cfg_inter_rat_s& other) const { return not(*this == other); }
};
// MeasGapConfigToAddModList-r14 ::= SEQUENCE (SIZE (1..32)) OF MeasGapConfigPerCC-r14
using meas_gap_cfg_to_add_mod_list_r14_l = dyn_array<meas_gap_cfg_per_cc_r14_s>;
// MeasGapConfigToRemoveList-r14 ::= SEQUENCE (SIZE (1..32)) OF INTEGER (0..31)
using meas_gap_cfg_to_rem_list_r14_l = bounded_array<uint8_t, 32>;
// MeasIdToAddMod ::= SEQUENCE
struct meas_id_to_add_mod_s {
uint8_t meas_id = 1;
uint8_t meas_obj_id = 1;
uint8_t report_cfg_id = 1;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_id_to_add_mod_s& other) const;
bool operator!=(const meas_id_to_add_mod_s& other) const { return not(*this == other); }
};
// MeasIdToAddMod-v1310 ::= SEQUENCE
struct meas_id_to_add_mod_v1310_s {
bool meas_obj_id_v1310_present = false;
uint8_t meas_obj_id_v1310 = 33;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasIdToAddModExt-r12 ::= SEQUENCE
struct meas_id_to_add_mod_ext_r12_s {
uint8_t meas_id_v1250 = 33;
uint8_t meas_obj_id_r12 = 1;
uint8_t report_cfg_id_r12 = 1;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasObjectToAddMod ::= SEQUENCE
struct meas_obj_to_add_mod_s {
struct meas_obj_c_ {
struct types_opts {
enum options {
meas_obj_eutra,
meas_obj_utra,
meas_obj_geran,
meas_obj_cdma2000,
// ...
meas_obj_wlan_r13,
meas_obj_nr_r15,
nulltype
} value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<types_opts, true, 2> types;
// choice methods
meas_obj_c_() = default;
meas_obj_c_(const meas_obj_c_& other);
meas_obj_c_& operator=(const meas_obj_c_& other);
~meas_obj_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_obj_c_& other) const;
bool operator!=(const meas_obj_c_& other) const { return not(*this == other); }
// getters
meas_obj_eutra_s& meas_obj_eutra()
{
assert_choice_type("measObjectEUTRA", type_.to_string(), "measObject");
return c.get<meas_obj_eutra_s>();
}
meas_obj_utra_s& meas_obj_utra()
{
assert_choice_type("measObjectUTRA", type_.to_string(), "measObject");
return c.get<meas_obj_utra_s>();
}
meas_obj_geran_s& meas_obj_geran()
{
assert_choice_type("measObjectGERAN", type_.to_string(), "measObject");
return c.get<meas_obj_geran_s>();
}
meas_obj_cdma2000_s& meas_obj_cdma2000()
{
assert_choice_type("measObjectCDMA2000", type_.to_string(), "measObject");
return c.get<meas_obj_cdma2000_s>();
}
meas_obj_wlan_r13_s& meas_obj_wlan_r13()
{
assert_choice_type("measObjectWLAN-r13", type_.to_string(), "measObject");
return c.get<meas_obj_wlan_r13_s>();
}
meas_obj_nr_r15_s& meas_obj_nr_r15()
{
assert_choice_type("measObjectNR-r15", type_.to_string(), "measObject");
return c.get<meas_obj_nr_r15_s>();
}
const meas_obj_eutra_s& meas_obj_eutra() const
{
assert_choice_type("measObjectEUTRA", type_.to_string(), "measObject");
return c.get<meas_obj_eutra_s>();
}
const meas_obj_utra_s& meas_obj_utra() const
{
assert_choice_type("measObjectUTRA", type_.to_string(), "measObject");
return c.get<meas_obj_utra_s>();
}
const meas_obj_geran_s& meas_obj_geran() const
{
assert_choice_type("measObjectGERAN", type_.to_string(), "measObject");
return c.get<meas_obj_geran_s>();
}
const meas_obj_cdma2000_s& meas_obj_cdma2000() const
{
assert_choice_type("measObjectCDMA2000", type_.to_string(), "measObject");
return c.get<meas_obj_cdma2000_s>();
}
const meas_obj_wlan_r13_s& meas_obj_wlan_r13() const
{
assert_choice_type("measObjectWLAN-r13", type_.to_string(), "measObject");
return c.get<meas_obj_wlan_r13_s>();
}
const meas_obj_nr_r15_s& meas_obj_nr_r15() const
{
assert_choice_type("measObjectNR-r15", type_.to_string(), "measObject");
return c.get<meas_obj_nr_r15_s>();
}
meas_obj_eutra_s& set_meas_obj_eutra()
{
set(types::meas_obj_eutra);
return c.get<meas_obj_eutra_s>();
}
meas_obj_utra_s& set_meas_obj_utra()
{
set(types::meas_obj_utra);
return c.get<meas_obj_utra_s>();
}
meas_obj_geran_s& set_meas_obj_geran()
{
set(types::meas_obj_geran);
return c.get<meas_obj_geran_s>();
}
meas_obj_cdma2000_s& set_meas_obj_cdma2000()
{
set(types::meas_obj_cdma2000);
return c.get<meas_obj_cdma2000_s>();
}
meas_obj_wlan_r13_s& set_meas_obj_wlan_r13()
{
set(types::meas_obj_wlan_r13);
return c.get<meas_obj_wlan_r13_s>();
}
meas_obj_nr_r15_s& set_meas_obj_nr_r15()
{
set(types::meas_obj_nr_r15);
return c.get<meas_obj_nr_r15_s>();
}
private:
types type_;
choice_buffer_t<meas_obj_cdma2000_s,
meas_obj_eutra_s,
meas_obj_geran_s,
meas_obj_nr_r15_s,
meas_obj_utra_s,
meas_obj_wlan_r13_s>
c;
void destroy_();
};
// member variables
uint8_t meas_obj_id = 1;
meas_obj_c_ meas_obj;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const meas_obj_to_add_mod_s& other) const;
bool operator!=(const meas_obj_to_add_mod_s& other) const { return not(*this == other); }
};
// MeasObjectToAddMod-v9e0 ::= SEQUENCE
struct meas_obj_to_add_mod_v9e0_s {
bool meas_obj_eutra_v9e0_present = false;
meas_obj_eutra_v9e0_s meas_obj_eutra_v9e0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasObjectToAddModExt-r13 ::= SEQUENCE
struct meas_obj_to_add_mod_ext_r13_s {
struct meas_obj_r13_c_ {
struct types_opts {
enum options {
meas_obj_eutra_r13,
meas_obj_utra_r13,
meas_obj_geran_r13,
meas_obj_cdma2000_r13,
// ...
meas_obj_wlan_v1320,
meas_obj_nr_r15,
nulltype
} value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<types_opts, true, 2> types;
// choice methods
meas_obj_r13_c_() = default;
meas_obj_r13_c_(const meas_obj_r13_c_& other);
meas_obj_r13_c_& operator=(const meas_obj_r13_c_& other);
~meas_obj_r13_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
meas_obj_eutra_s& meas_obj_eutra_r13()
{
assert_choice_type("measObjectEUTRA-r13", type_.to_string(), "measObject-r13");
return c.get<meas_obj_eutra_s>();
}
meas_obj_utra_s& meas_obj_utra_r13()
{
assert_choice_type("measObjectUTRA-r13", type_.to_string(), "measObject-r13");
return c.get<meas_obj_utra_s>();
}
meas_obj_geran_s& meas_obj_geran_r13()
{
assert_choice_type("measObjectGERAN-r13", type_.to_string(), "measObject-r13");
return c.get<meas_obj_geran_s>();
}
meas_obj_cdma2000_s& meas_obj_cdma2000_r13()
{
assert_choice_type("measObjectCDMA2000-r13", type_.to_string(), "measObject-r13");
return c.get<meas_obj_cdma2000_s>();
}
meas_obj_wlan_r13_s& meas_obj_wlan_v1320()
{
assert_choice_type("measObjectWLAN-v1320", type_.to_string(), "measObject-r13");
return c.get<meas_obj_wlan_r13_s>();
}
meas_obj_nr_r15_s& meas_obj_nr_r15()
{
assert_choice_type("measObjectNR-r15", type_.to_string(), "measObject-r13");
return c.get<meas_obj_nr_r15_s>();
}
const meas_obj_eutra_s& meas_obj_eutra_r13() const
{
assert_choice_type("measObjectEUTRA-r13", type_.to_string(), "measObject-r13");
return c.get<meas_obj_eutra_s>();
}
const meas_obj_utra_s& meas_obj_utra_r13() const
{
assert_choice_type("measObjectUTRA-r13", type_.to_string(), "measObject-r13");
return c.get<meas_obj_utra_s>();
}
const meas_obj_geran_s& meas_obj_geran_r13() const
{
assert_choice_type("measObjectGERAN-r13", type_.to_string(), "measObject-r13");
return c.get<meas_obj_geran_s>();
}
const meas_obj_cdma2000_s& meas_obj_cdma2000_r13() const
{
assert_choice_type("measObjectCDMA2000-r13", type_.to_string(), "measObject-r13");
return c.get<meas_obj_cdma2000_s>();
}
const meas_obj_wlan_r13_s& meas_obj_wlan_v1320() const
{
assert_choice_type("measObjectWLAN-v1320", type_.to_string(), "measObject-r13");
return c.get<meas_obj_wlan_r13_s>();
}
const meas_obj_nr_r15_s& meas_obj_nr_r15() const
{
assert_choice_type("measObjectNR-r15", type_.to_string(), "measObject-r13");
return c.get<meas_obj_nr_r15_s>();
}
meas_obj_eutra_s& set_meas_obj_eutra_r13()
{
set(types::meas_obj_eutra_r13);
return c.get<meas_obj_eutra_s>();
}
meas_obj_utra_s& set_meas_obj_utra_r13()
{
set(types::meas_obj_utra_r13);
return c.get<meas_obj_utra_s>();
}
meas_obj_geran_s& set_meas_obj_geran_r13()
{
set(types::meas_obj_geran_r13);
return c.get<meas_obj_geran_s>();
}
meas_obj_cdma2000_s& set_meas_obj_cdma2000_r13()
{
set(types::meas_obj_cdma2000_r13);
return c.get<meas_obj_cdma2000_s>();
}
meas_obj_wlan_r13_s& set_meas_obj_wlan_v1320()
{
set(types::meas_obj_wlan_v1320);
return c.get<meas_obj_wlan_r13_s>();
}
meas_obj_nr_r15_s& set_meas_obj_nr_r15()
{
set(types::meas_obj_nr_r15);
return c.get<meas_obj_nr_r15_s>();
}
private:
types type_;
choice_buffer_t<meas_obj_cdma2000_s,
meas_obj_eutra_s,
meas_obj_geran_s,
meas_obj_nr_r15_s,
meas_obj_utra_s,
meas_obj_wlan_r13_s>
c;
void destroy_();
};
// member variables
uint8_t meas_obj_id_r13 = 33;
meas_obj_r13_c_ meas_obj_r13;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// QuantityConfigCDMA2000 ::= SEQUENCE
struct quant_cfg_cdma2000_s {
struct meas_quant_cdma2000_opts {
enum options { pilot_strength, pilot_pn_phase_and_pilot_strength, nulltype } value;
std::string to_string() const;
};
typedef enumerated<meas_quant_cdma2000_opts> meas_quant_cdma2000_e_;
// member variables
meas_quant_cdma2000_e_ meas_quant_cdma2000;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_cdma2000_s& other) const;
bool operator!=(const quant_cfg_cdma2000_s& other) const { return not(*this == other); }
};
// QuantityConfigEUTRA ::= SEQUENCE
struct quant_cfg_eutra_s {
bool filt_coef_rsrp_present = false;
bool filt_coef_rsrq_present = false;
filt_coef_e filt_coef_rsrp;
filt_coef_e filt_coef_rsrq;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_eutra_s& other) const;
bool operator!=(const quant_cfg_eutra_s& other) const { return not(*this == other); }
};
// QuantityConfigEUTRA-v1250 ::= SEQUENCE
struct quant_cfg_eutra_v1250_s {
bool filt_coef_csi_rsrp_r12_present = false;
filt_coef_e filt_coef_csi_rsrp_r12;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_eutra_v1250_s& other) const;
bool operator!=(const quant_cfg_eutra_v1250_s& other) const { return not(*this == other); }
};
// QuantityConfigEUTRA-v1310 ::= SEQUENCE
struct quant_cfg_eutra_v1310_s {
bool filt_coef_rs_sinr_r13_present = false;
filt_coef_e filt_coef_rs_sinr_r13;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_eutra_v1310_s& other) const;
bool operator!=(const quant_cfg_eutra_v1310_s& other) const { return not(*this == other); }
};
// QuantityConfigGERAN ::= SEQUENCE
struct quant_cfg_geran_s {
bool filt_coef_present = false;
filt_coef_e filt_coef;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_geran_s& other) const;
bool operator!=(const quant_cfg_geran_s& other) const { return not(*this == other); }
};
// QuantityConfigNRList-r15 ::= SEQUENCE (SIZE (1..2)) OF QuantityConfigNR-r15
using quant_cfg_nr_list_r15_l = dyn_array<quant_cfg_nr_r15_s>;
// QuantityConfigUTRA ::= SEQUENCE
struct quant_cfg_utra_s {
struct meas_quant_utra_fdd_opts {
enum options { cpich_rscp, cpich_ec_n0, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<meas_quant_utra_fdd_opts> meas_quant_utra_fdd_e_;
// member variables
bool filt_coef_present = false;
meas_quant_utra_fdd_e_ meas_quant_utra_fdd;
filt_coef_e filt_coef;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_utra_s& other) const;
bool operator!=(const quant_cfg_utra_s& other) const { return not(*this == other); }
};
// QuantityConfigUTRA-v1020 ::= SEQUENCE
struct quant_cfg_utra_v1020_s {
bool filt_coef2_fdd_r10_present = false;
filt_coef_e filt_coef2_fdd_r10;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_utra_v1020_s& other) const;
bool operator!=(const quant_cfg_utra_v1020_s& other) const { return not(*this == other); }
};
// QuantityConfigWLAN-r13 ::= SEQUENCE
struct quant_cfg_wlan_r13_s {
bool filt_coef_r13_present = false;
filt_coef_e filt_coef_r13;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_wlan_r13_s& other) const;
bool operator!=(const quant_cfg_wlan_r13_s& other) const { return not(*this == other); }
};
// ReportConfigToAddMod ::= SEQUENCE
struct report_cfg_to_add_mod_s {
struct report_cfg_c_ {
struct types_opts {
enum options { report_cfg_eutra, report_cfg_inter_rat, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
report_cfg_c_() = default;
report_cfg_c_(const report_cfg_c_& other);
report_cfg_c_& operator=(const report_cfg_c_& other);
~report_cfg_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const report_cfg_c_& other) const;
bool operator!=(const report_cfg_c_& other) const { return not(*this == other); }
// getters
report_cfg_eutra_s& report_cfg_eutra()
{
assert_choice_type("reportConfigEUTRA", type_.to_string(), "reportConfig");
return c.get<report_cfg_eutra_s>();
}
report_cfg_inter_rat_s& report_cfg_inter_rat()
{
assert_choice_type("reportConfigInterRAT", type_.to_string(), "reportConfig");
return c.get<report_cfg_inter_rat_s>();
}
const report_cfg_eutra_s& report_cfg_eutra() const
{
assert_choice_type("reportConfigEUTRA", type_.to_string(), "reportConfig");
return c.get<report_cfg_eutra_s>();
}
const report_cfg_inter_rat_s& report_cfg_inter_rat() const
{
assert_choice_type("reportConfigInterRAT", type_.to_string(), "reportConfig");
return c.get<report_cfg_inter_rat_s>();
}
report_cfg_eutra_s& set_report_cfg_eutra()
{
set(types::report_cfg_eutra);
return c.get<report_cfg_eutra_s>();
}
report_cfg_inter_rat_s& set_report_cfg_inter_rat()
{
set(types::report_cfg_inter_rat);
return c.get<report_cfg_inter_rat_s>();
}
private:
types type_;
choice_buffer_t<report_cfg_eutra_s, report_cfg_inter_rat_s> c;
void destroy_();
};
// member variables
uint8_t report_cfg_id = 1;
report_cfg_c_ report_cfg;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const report_cfg_to_add_mod_s& other) const;
bool operator!=(const report_cfg_to_add_mod_s& other) const { return not(*this == other); }
};
// MeasGapConfigDensePRS-r15 ::= CHOICE
struct meas_gap_cfg_dense_prs_r15_c {
struct setup_s_ {
struct gap_offset_dense_prs_r15_c_ {
struct types_opts {
enum options {
rstd0_r15,
rstd1_r15,
rstd2_r15,
rstd3_r15,
rstd4_r15,
rstd5_r15,
rstd6_r15,
rstd7_r15,
rstd8_r15,
rstd9_r15,
rstd10_r15,
rstd11_r15,
rstd12_r15,
rstd13_r15,
rstd14_r15,
rstd15_r15,
rstd16_r15,
rstd17_r15,
rstd18_r15,
rstd19_r15,
rstd20_r15,
// ...
nulltype
} value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<types_opts, true> types;
// choice methods
gap_offset_dense_prs_r15_c_() = default;
gap_offset_dense_prs_r15_c_(const gap_offset_dense_prs_r15_c_& other);
gap_offset_dense_prs_r15_c_& operator=(const gap_offset_dense_prs_r15_c_& other);
~gap_offset_dense_prs_r15_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
uint8_t& rstd0_r15()
{
assert_choice_type("rstd0-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint8_t>();
}
uint8_t& rstd1_r15()
{
assert_choice_type("rstd1-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint8_t>();
}
uint16_t& rstd2_r15()
{
assert_choice_type("rstd2-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd3_r15()
{
assert_choice_type("rstd3-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd4_r15()
{
assert_choice_type("rstd4-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint8_t& rstd5_r15()
{
assert_choice_type("rstd5-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint8_t>();
}
uint16_t& rstd6_r15()
{
assert_choice_type("rstd6-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd7_r15()
{
assert_choice_type("rstd7-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd8_r15()
{
assert_choice_type("rstd8-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd9_r15()
{
assert_choice_type("rstd9-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd10_r15()
{
assert_choice_type("rstd10-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd11_r15()
{
assert_choice_type("rstd11-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd12_r15()
{
assert_choice_type("rstd12-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd13_r15()
{
assert_choice_type("rstd13-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd14_r15()
{
assert_choice_type("rstd14-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd15_r15()
{
assert_choice_type("rstd15-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd16_r15()
{
assert_choice_type("rstd16-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd17_r15()
{
assert_choice_type("rstd17-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd18_r15()
{
assert_choice_type("rstd18-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd19_r15()
{
assert_choice_type("rstd19-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint16_t& rstd20_r15()
{
assert_choice_type("rstd20-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint8_t& rstd0_r15() const
{
assert_choice_type("rstd0-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint8_t>();
}
const uint8_t& rstd1_r15() const
{
assert_choice_type("rstd1-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint8_t>();
}
const uint16_t& rstd2_r15() const
{
assert_choice_type("rstd2-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd3_r15() const
{
assert_choice_type("rstd3-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd4_r15() const
{
assert_choice_type("rstd4-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint8_t& rstd5_r15() const
{
assert_choice_type("rstd5-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint8_t>();
}
const uint16_t& rstd6_r15() const
{
assert_choice_type("rstd6-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd7_r15() const
{
assert_choice_type("rstd7-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd8_r15() const
{
assert_choice_type("rstd8-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd9_r15() const
{
assert_choice_type("rstd9-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd10_r15() const
{
assert_choice_type("rstd10-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd11_r15() const
{
assert_choice_type("rstd11-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd12_r15() const
{
assert_choice_type("rstd12-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd13_r15() const
{
assert_choice_type("rstd13-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd14_r15() const
{
assert_choice_type("rstd14-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd15_r15() const
{
assert_choice_type("rstd15-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd16_r15() const
{
assert_choice_type("rstd16-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd17_r15() const
{
assert_choice_type("rstd17-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd18_r15() const
{
assert_choice_type("rstd18-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd19_r15() const
{
assert_choice_type("rstd19-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
const uint16_t& rstd20_r15() const
{
assert_choice_type("rstd20-r15", type_.to_string(), "gapOffsetDensePRS-r15");
return c.get<uint16_t>();
}
uint8_t& set_rstd0_r15()
{
set(types::rstd0_r15);
return c.get<uint8_t>();
}
uint8_t& set_rstd1_r15()
{
set(types::rstd1_r15);
return c.get<uint8_t>();
}
uint16_t& set_rstd2_r15()
{
set(types::rstd2_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd3_r15()
{
set(types::rstd3_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd4_r15()
{
set(types::rstd4_r15);
return c.get<uint16_t>();
}
uint8_t& set_rstd5_r15()
{
set(types::rstd5_r15);
return c.get<uint8_t>();
}
uint16_t& set_rstd6_r15()
{
set(types::rstd6_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd7_r15()
{
set(types::rstd7_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd8_r15()
{
set(types::rstd8_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd9_r15()
{
set(types::rstd9_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd10_r15()
{
set(types::rstd10_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd11_r15()
{
set(types::rstd11_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd12_r15()
{
set(types::rstd12_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd13_r15()
{
set(types::rstd13_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd14_r15()
{
set(types::rstd14_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd15_r15()
{
set(types::rstd15_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd16_r15()
{
set(types::rstd16_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd17_r15()
{
set(types::rstd17_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd18_r15()
{
set(types::rstd18_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd19_r15()
{
set(types::rstd19_r15);
return c.get<uint16_t>();
}
uint16_t& set_rstd20_r15()
{
set(types::rstd20_r15);
return c.get<uint16_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
// member variables
gap_offset_dense_prs_r15_c_ gap_offset_dense_prs_r15;
};
typedef setup_e types;
// choice methods
meas_gap_cfg_dense_prs_r15_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "MeasGapConfigDensePRS-r15");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "MeasGapConfigDensePRS-r15");
return c;
}
setup_s_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_s_ c;
};
// MeasGapConfigPerCC-List-r14 ::= CHOICE
struct meas_gap_cfg_per_cc_list_r14_c {
struct setup_s_ {
bool meas_gap_cfg_to_rem_list_r14_present = false;
bool meas_gap_cfg_to_add_mod_list_r14_present = false;
meas_gap_cfg_to_rem_list_r14_l meas_gap_cfg_to_rem_list_r14;
meas_gap_cfg_to_add_mod_list_r14_l meas_gap_cfg_to_add_mod_list_r14;
};
typedef setup_e types;
// choice methods
meas_gap_cfg_per_cc_list_r14_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "MeasGapConfigPerCC-List-r14");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "MeasGapConfigPerCC-List-r14");
return c;
}
setup_s_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_s_ c;
};
// MeasGapSharingConfig-r14 ::= CHOICE
struct meas_gap_sharing_cfg_r14_c {
struct setup_s_ {
struct meas_gap_sharing_scheme_r14_opts {
enum options { scheme00, scheme01, scheme10, scheme11, nulltype } value;
typedef float number_type;
std::string to_string() const;
float to_number() const;
std::string to_number_string() const;
};
typedef enumerated<meas_gap_sharing_scheme_r14_opts> meas_gap_sharing_scheme_r14_e_;
// member variables
meas_gap_sharing_scheme_r14_e_ meas_gap_sharing_scheme_r14;
};
typedef setup_e types;
// choice methods
meas_gap_sharing_cfg_r14_c() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "MeasGapSharingConfig-r14");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "MeasGapSharingConfig-r14");
return c;
}
setup_s_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_s_ c;
};
// MeasIdToAddModList ::= SEQUENCE (SIZE (1..32)) OF MeasIdToAddMod
using meas_id_to_add_mod_list_l = dyn_array<meas_id_to_add_mod_s>;
// MeasIdToAddModList-v1310 ::= SEQUENCE (SIZE (1..32)) OF MeasIdToAddMod-v1310
using meas_id_to_add_mod_list_v1310_l = dyn_array<meas_id_to_add_mod_v1310_s>;
// MeasIdToAddModListExt-r12 ::= SEQUENCE (SIZE (1..32)) OF MeasIdToAddModExt-r12
using meas_id_to_add_mod_list_ext_r12_l = dyn_array<meas_id_to_add_mod_ext_r12_s>;
// MeasIdToAddModListExt-v1310 ::= SEQUENCE (SIZE (1..32)) OF MeasIdToAddMod-v1310
using meas_id_to_add_mod_list_ext_v1310_l = dyn_array<meas_id_to_add_mod_v1310_s>;
// MeasIdToRemoveList ::= SEQUENCE (SIZE (1..32)) OF INTEGER (1..32)
using meas_id_to_rem_list_l = bounded_array<uint8_t, 32>;
// MeasIdToRemoveListExt-r12 ::= SEQUENCE (SIZE (1..32)) OF INTEGER (33..64)
using meas_id_to_rem_list_ext_r12_l = bounded_array<uint8_t, 32>;
// MeasObjectToAddModList ::= SEQUENCE (SIZE (1..32)) OF MeasObjectToAddMod
using meas_obj_to_add_mod_list_l = dyn_array<meas_obj_to_add_mod_s>;
// MeasObjectToAddModList-v9e0 ::= SEQUENCE (SIZE (1..32)) OF MeasObjectToAddMod-v9e0
using meas_obj_to_add_mod_list_v9e0_l = dyn_array<meas_obj_to_add_mod_v9e0_s>;
// MeasObjectToAddModListExt-r13 ::= SEQUENCE (SIZE (1..32)) OF MeasObjectToAddModExt-r13
using meas_obj_to_add_mod_list_ext_r13_l = dyn_array<meas_obj_to_add_mod_ext_r13_s>;
// MeasObjectToRemoveList ::= SEQUENCE (SIZE (1..32)) OF INTEGER (1..32)
using meas_obj_to_rem_list_l = bounded_array<uint8_t, 32>;
// MeasObjectToRemoveListExt-r13 ::= SEQUENCE (SIZE (1..32)) OF INTEGER (33..64)
using meas_obj_to_rem_list_ext_r13_l = bounded_array<uint8_t, 32>;
// MeasScaleFactor-r12 ::= ENUMERATED
struct meas_scale_factor_r12_opts {
enum options { sf_eutra_cf1, sf_eutra_cf2, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<meas_scale_factor_r12_opts> meas_scale_factor_r12_e;
// QuantityConfig ::= SEQUENCE
struct quant_cfg_s {
bool ext = false;
bool quant_cfg_eutra_present = false;
bool quant_cfg_utra_present = false;
bool quant_cfg_geran_present = false;
bool quant_cfg_cdma2000_present = false;
quant_cfg_eutra_s quant_cfg_eutra;
quant_cfg_utra_s quant_cfg_utra;
quant_cfg_geran_s quant_cfg_geran;
quant_cfg_cdma2000_s quant_cfg_cdma2000;
// ...
// group 0
copy_ptr<quant_cfg_utra_v1020_s> quant_cfg_utra_v1020;
// group 1
copy_ptr<quant_cfg_eutra_v1250_s> quant_cfg_eutra_v1250;
// group 2
copy_ptr<quant_cfg_eutra_v1310_s> quant_cfg_eutra_v1310;
copy_ptr<quant_cfg_wlan_r13_s> quant_cfg_wlan_r13;
// group 3
copy_ptr<quant_cfg_nr_list_r15_l> quant_cfg_nr_list_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
bool operator==(const quant_cfg_s& other) const;
bool operator!=(const quant_cfg_s& other) const { return not(*this == other); }
};
update RRC ASN1 to 2020-09 v15.11
4 years ago
// RACH-ConfigDedicated ::= SEQUENCE
struct rach_cfg_ded_s {
uint8_t ra_preamb_idx = 0;
uint8_t ra_prach_mask_idx = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// RACH-Skip-r14 ::= SEQUENCE
struct rach_skip_r14_s {
struct target_ta_r14_c_ {
struct types_opts {
enum options { ta0_r14, mcg_ptag_r14, scg_ptag_r14, mcg_stag_r14, scg_stag_r14, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<types_opts> types;
// choice methods
target_ta_r14_c_() = default;
target_ta_r14_c_(const target_ta_r14_c_& other);
target_ta_r14_c_& operator=(const target_ta_r14_c_& other);
~target_ta_r14_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
uint8_t& mcg_stag_r14()
{
assert_choice_type("mcg-STAG-r14", type_.to_string(), "targetTA-r14");
return c.get<uint8_t>();
}
uint8_t& scg_stag_r14()
{
assert_choice_type("scg-STAG-r14", type_.to_string(), "targetTA-r14");
return c.get<uint8_t>();
}
const uint8_t& mcg_stag_r14() const
{
assert_choice_type("mcg-STAG-r14", type_.to_string(), "targetTA-r14");
return c.get<uint8_t>();
}
const uint8_t& scg_stag_r14() const
{
assert_choice_type("scg-STAG-r14", type_.to_string(), "targetTA-r14");
return c.get<uint8_t>();
}
uint8_t& set_mcg_stag_r14()
{
set(types::mcg_stag_r14);
return c.get<uint8_t>();
}
uint8_t& set_scg_stag_r14()
{
set(types::scg_stag_r14);
return c.get<uint8_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
struct ul_cfg_info_r14_s_ {
struct ul_sched_interv_r14_opts {
enum options { sf2, sf5, sf10, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<ul_sched_interv_r14_opts> ul_sched_interv_r14_e_;
// member variables
uint8_t nof_conf_ul_processes_r14 = 1;
ul_sched_interv_r14_e_ ul_sched_interv_r14;
uint8_t ul_start_sf_r14 = 0;
fixed_bitstring<16> ul_grant_r14;
};
// member variables
bool ul_cfg_info_r14_present = false;
target_ta_r14_c_ target_ta_r14;
ul_cfg_info_r14_s_ ul_cfg_info_r14;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
update nr asn1 files, and asn1 tests
4 years ago
// ReportConfigToAddModList ::= SEQUENCE (SIZE (1..32)) OF ReportConfigToAddMod
using report_cfg_to_add_mod_list_l = dyn_array<report_cfg_to_add_mod_s>;
// ReportConfigToRemoveList ::= SEQUENCE (SIZE (1..32)) OF INTEGER (1..32)
using report_cfg_to_rem_list_l = bounded_array<uint8_t, 32>;
// MeasConfig ::= SEQUENCE
struct meas_cfg_s {
struct speed_state_pars_c_ {
struct setup_s_ {
mob_state_params_s mob_state_params;
speed_state_scale_factors_s time_to_trigger_sf;
};
typedef setup_e types;
// choice methods
speed_state_pars_c_() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "speedStatePars");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "speedStatePars");
return c;
}
setup_s_& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
setup_s_ c;
};
struct meas_scale_factor_r12_c_ {
typedef setup_e types;
// choice methods
meas_scale_factor_r12_c_() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
meas_scale_factor_r12_e& setup()
{
assert_choice_type("setup", type_.to_string(), "measScaleFactor-r12");
return c;
}
const meas_scale_factor_r12_e& setup() const
{
assert_choice_type("setup", type_.to_string(), "measScaleFactor-r12");
return c;
}
meas_scale_factor_r12_e& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
meas_scale_factor_r12_e c;
};
struct height_thresh_ref_r15_c_ {
typedef setup_e types;
// choice methods
height_thresh_ref_r15_c_() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
uint8_t& setup()
{
assert_choice_type("setup", type_.to_string(), "heightThreshRef-r15");
return c;
}
const uint8_t& setup() const
{
assert_choice_type("setup", type_.to_string(), "heightThreshRef-r15");
return c;
}
uint8_t& set_setup()
{
set(types::setup);
return c;
}
private:
types type_;
uint8_t c;
};
// member variables
bool ext = false;
bool meas_obj_to_rem_list_present = false;
bool meas_obj_to_add_mod_list_present = false;
bool report_cfg_to_rem_list_present = false;
bool report_cfg_to_add_mod_list_present = false;
bool meas_id_to_rem_list_present = false;
bool meas_id_to_add_mod_list_present = false;
bool quant_cfg_present = false;
bool meas_gap_cfg_present = false;
bool s_measure_present = false;
bool pre_regist_info_hrpd_present = false;
bool speed_state_pars_present = false;
meas_obj_to_rem_list_l meas_obj_to_rem_list;
meas_obj_to_add_mod_list_l meas_obj_to_add_mod_list;
report_cfg_to_rem_list_l report_cfg_to_rem_list;
report_cfg_to_add_mod_list_l report_cfg_to_add_mod_list;
meas_id_to_rem_list_l meas_id_to_rem_list;
meas_id_to_add_mod_list_l meas_id_to_add_mod_list;
quant_cfg_s quant_cfg;
meas_gap_cfg_c meas_gap_cfg;
uint8_t s_measure = 0;
pre_regist_info_hrpd_s pre_regist_info_hrpd;
speed_state_pars_c_ speed_state_pars;
// ...
// group 0
copy_ptr<meas_obj_to_add_mod_list_v9e0_l> meas_obj_to_add_mod_list_v9e0;
// group 1
bool allow_interruptions_r11_present = false;
bool allow_interruptions_r11 = false;
// group 2
bool meas_rsrq_on_all_symbols_r12_present = false;
copy_ptr<meas_scale_factor_r12_c_> meas_scale_factor_r12;
copy_ptr<meas_id_to_rem_list_ext_r12_l> meas_id_to_rem_list_ext_r12;
copy_ptr<meas_id_to_add_mod_list_ext_r12_l> meas_id_to_add_mod_list_ext_r12;
bool meas_rsrq_on_all_symbols_r12 = false;
// group 3
copy_ptr<meas_obj_to_rem_list_ext_r13_l> meas_obj_to_rem_list_ext_r13;
copy_ptr<meas_obj_to_add_mod_list_ext_r13_l> meas_obj_to_add_mod_list_ext_r13;
copy_ptr<meas_id_to_add_mod_list_v1310_l> meas_id_to_add_mod_list_v1310;
copy_ptr<meas_id_to_add_mod_list_ext_v1310_l> meas_id_to_add_mod_list_ext_v1310;
// group 4
copy_ptr<meas_gap_cfg_per_cc_list_r14_c> meas_gap_cfg_per_cc_list_r14;
copy_ptr<meas_gap_sharing_cfg_r14_c> meas_gap_sharing_cfg_r14;
// group 5
bool fr1_gap_r15_present = false;
bool mgta_r15_present = false;
bool fr1_gap_r15 = false;
bool mgta_r15 = false;
// group 6
copy_ptr<meas_gap_cfg_dense_prs_r15_c> meas_gap_cfg_dense_prs_r15;
copy_ptr<height_thresh_ref_r15_c_> height_thresh_ref_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
update RRC ASN1 to 2020-09 v15.11
4 years ago
// CarrierFreqGERAN ::= SEQUENCE
struct carrier_freq_geran_s {
uint16_t arfcn = 0;
band_ind_geran_e band_ind;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MobilityControlInfo-v10l0 ::= SEQUENCE
struct mob_ctrl_info_v10l0_s {
bool add_spec_emission_v10l0_present = false;
uint16_t add_spec_emission_v10l0 = 33;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// LoggedMeasurementConfiguration-v1530-IEs ::= SEQUENCE
struct logged_meas_cfg_v1530_ies_s {
bool bt_name_list_r15_present = false;
bool wlan_name_list_r15_present = false;
bool non_crit_ext_present = false;
bt_name_list_r15_l bt_name_list_r15;
wlan_name_list_r15_l wlan_name_list_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// CellGlobalIdEUTRA ::= SEQUENCE
struct cell_global_id_eutra_s {
plmn_id_s plmn_id;
fixed_bitstring<28> cell_id;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// CarrierBandwidthEUTRA ::= SEQUENCE
struct carrier_bw_eutra_s {
struct dl_bw_opts {
enum options {
n6,
n15,
n25,
n50,
n75,
n100,
spare10,
spare9,
spare8,
spare7,
spare6,
spare5,
spare4,
spare3,
spare2,
spare1,
nulltype
} value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<dl_bw_opts> dl_bw_e_;
struct ul_bw_opts {
enum options {
n6,
n15,
n25,
n50,
n75,
n100,
spare10,
spare9,
spare8,
spare7,
spare6,
spare5,
spare4,
spare3,
spare2,
spare1,
nulltype
} value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<ul_bw_opts> ul_bw_e_;
// member variables
bool ul_bw_present = false;
dl_bw_e_ dl_bw;
ul_bw_e_ ul_bw;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// CarrierFreqEUTRA ::= SEQUENCE
struct carrier_freq_eutra_s {
bool ul_carrier_freq_present = false;
uint32_t dl_carrier_freq = 0;
uint32_t ul_carrier_freq = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// CarrierFreqEUTRA-v9e0 ::= SEQUENCE
struct carrier_freq_eutra_v9e0_s {
bool ul_carrier_freq_v9e0_present = false;
uint32_t dl_carrier_freq_v9e0 = 0;
uint32_t ul_carrier_freq_v9e0 = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MobilityControlInfoV2X-r14 ::= SEQUENCE
struct mob_ctrl_info_v2x_r14_s {
bool v2x_comm_tx_pool_exceptional_r14_present = false;
bool v2x_comm_rx_pool_r14_present = false;
bool v2x_comm_sync_cfg_r14_present = false;
bool cbr_mob_tx_cfg_list_r14_present = false;
sl_comm_res_pool_v2x_r14_s v2x_comm_tx_pool_exceptional_r14;
sl_comm_rx_pool_list_v2x_r14_l v2x_comm_rx_pool_r14;
sl_sync_cfg_list_v2x_r14_l v2x_comm_sync_cfg_r14;
sl_cbr_common_tx_cfg_list_r14_s cbr_mob_tx_cfg_list_r14;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
update nr asn1 files, and asn1 tests
4 years ago
// MobilityControlInfo ::= SEQUENCE
struct mob_ctrl_info_s {
struct t304_opts {
enum options { ms50, ms100, ms150, ms200, ms500, ms1000, ms2000, ms10000_v1310, nulltype } value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<t304_opts> t304_e_;
struct ho_without_wt_change_r14_opts {
enum options { keep_lwa_cfg, send_end_marker, nulltype } value;
std::string to_string() const;
};
typedef enumerated<ho_without_wt_change_r14_opts> ho_without_wt_change_r14_e_;
// member variables
bool ext = false;
bool carrier_freq_present = false;
bool carrier_bw_present = false;
bool add_spec_emission_present = false;
bool rach_cfg_ded_present = false;
uint16_t target_pci = 0;
carrier_freq_eutra_s carrier_freq;
carrier_bw_eutra_s carrier_bw;
uint8_t add_spec_emission = 1;
t304_e_ t304;
fixed_bitstring<16> new_ue_id;
rr_cfg_common_s rr_cfg_common;
rach_cfg_ded_s rach_cfg_ded;
// ...
// group 0
copy_ptr<carrier_freq_eutra_v9e0_s> carrier_freq_v9e0;
// group 1
bool drb_continue_rohc_r11_present = false;
// group 2
bool ho_without_wt_change_r14_present = false;
bool make_before_break_r14_present = false;
bool same_sfn_ind_r14_present = false;
copy_ptr<mob_ctrl_info_v2x_r14_s> mob_ctrl_info_v2x_r14;
ho_without_wt_change_r14_e_ ho_without_wt_change_r14;
copy_ptr<rach_skip_r14_s> rach_skip_r14;
// group 3
bool mib_repeat_status_r14_present = false;
bool sched_info_sib1_br_r14_present = false;
bool mib_repeat_status_r14 = false;
uint8_t sched_info_sib1_br_r14 = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// TraceReference-r10 ::= SEQUENCE
struct trace_ref_r10_s {
plmn_id_s plmn_id_r10;
fixed_octstring<3> trace_id_r10;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// CellGlobalIdCDMA2000 ::= CHOICE
struct cell_global_id_cdma2000_c {
struct types_opts {
enum options { cell_global_id1_xrtt, cell_global_id_hrpd, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<types_opts> types;
// choice methods
cell_global_id_cdma2000_c() = default;
cell_global_id_cdma2000_c(const cell_global_id_cdma2000_c& other);
cell_global_id_cdma2000_c& operator=(const cell_global_id_cdma2000_c& other);
~cell_global_id_cdma2000_c() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
fixed_bitstring<47>& cell_global_id1_xrtt()
{
assert_choice_type("cellGlobalId1XRTT", type_.to_string(), "CellGlobalIdCDMA2000");
return c.get<fixed_bitstring<47> >();
}
fixed_bitstring<128>& cell_global_id_hrpd()
{
assert_choice_type("cellGlobalIdHRPD", type_.to_string(), "CellGlobalIdCDMA2000");
return c.get<fixed_bitstring<128> >();
}
const fixed_bitstring<47>& cell_global_id1_xrtt() const
{
assert_choice_type("cellGlobalId1XRTT", type_.to_string(), "CellGlobalIdCDMA2000");
return c.get<fixed_bitstring<47> >();
}
const fixed_bitstring<128>& cell_global_id_hrpd() const
{
assert_choice_type("cellGlobalIdHRPD", type_.to_string(), "CellGlobalIdCDMA2000");
return c.get<fixed_bitstring<128> >();
}
fixed_bitstring<47>& set_cell_global_id1_xrtt()
{
set(types::cell_global_id1_xrtt);
return c.get<fixed_bitstring<47> >();
}
fixed_bitstring<128>& set_cell_global_id_hrpd()
{
set(types::cell_global_id_hrpd);
return c.get<fixed_bitstring<128> >();
}
private:
types type_;
choice_buffer_t<fixed_bitstring<128> > c;
void destroy_();
};
// AdditionalSI-Info-r9 ::= SEQUENCE
struct add_si_info_r9_s {
bool csg_member_status_r9_present = false;
bool csg_id_r9_present = false;
fixed_bitstring<27> csg_id_r9;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// BLER-Result-r12 ::= SEQUENCE
struct bler_result_r12_s {
struct blocks_rx_r12_s_ {
fixed_bitstring<3> n_r12;
fixed_bitstring<8> m_r12;
};
// member variables
uint8_t bler_r12 = 0;
blocks_rx_r12_s_ blocks_rx_r12;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// CellGlobalIdUTRA ::= SEQUENCE
struct cell_global_id_utra_s {
plmn_id_s plmn_id;
fixed_bitstring<28> cell_id;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultCDMA2000 ::= SEQUENCE
struct meas_result_cdma2000_s {
struct meas_result_s_ {
bool ext = false;
bool pilot_pn_phase_present = false;
uint16_t pilot_pn_phase = 0;
uint8_t pilot_strength = 0;
// ...
};
// member variables
bool cgi_info_present = false;
uint16_t pci = 0;
cell_global_id_cdma2000_c cgi_info;
meas_result_s_ meas_result;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// PLMN-IdentityList2 ::= SEQUENCE (SIZE (1..5)) OF PLMN-Identity
using plmn_id_list2_l = dyn_array<plmn_id_s>;
// CellGlobalIdGERAN ::= SEQUENCE
struct cell_global_id_geran_s {
plmn_id_s plmn_id;
fixed_bitstring<16> location_area_code;
fixed_bitstring<16> cell_id;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// DataBLER-MCH-Result-r12 ::= SEQUENCE
struct data_bler_mch_result_r12_s {
uint8_t mch_idx_r12 = 1;
bler_result_r12_s data_bler_result_r12;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultEUTRA ::= SEQUENCE
struct meas_result_eutra_s {
struct cgi_info_s_ {
bool plmn_id_list_present = false;
cell_global_id_eutra_s cell_global_id;
fixed_bitstring<16> tac;
plmn_id_list2_l plmn_id_list;
};
struct meas_result_s_ {
struct cgi_info_v1310_s_ {
bool freq_band_ind_r13_present = false;
bool multi_band_info_list_r13_present = false;
bool freq_band_ind_prio_r13_present = false;
uint16_t freq_band_ind_r13 = 1;
multi_band_info_list_r11_l multi_band_info_list_r13;
};
using cgi_info_minus5_gc_r15_l_ = dyn_array<cell_access_related_info_minus5_gc_r15_s>;
// member variables
bool ext = false;
bool rsrp_result_present = false;
bool rsrq_result_present = false;
uint8_t rsrp_result = 0;
uint8_t rsrq_result = 0;
// ...
// group 0
copy_ptr<add_si_info_r9_s> add_si_info_r9;
// group 1
bool primary_plmn_suitable_r12_present = false;
bool meas_result_v1250_present = false;
int8_t meas_result_v1250 = -30;
// group 2
bool rs_sinr_result_r13_present = false;
uint8_t rs_sinr_result_r13 = 0;
copy_ptr<cgi_info_v1310_s_> cgi_info_v1310;
// group 3
bool meas_result_v1360_present = false;
int8_t meas_result_v1360 = -17;
// group 4
copy_ptr<cgi_info_minus5_gc_r15_l_> cgi_info_minus5_gc_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// member variables
bool cgi_info_present = false;
uint16_t pci = 0;
cgi_info_s_ cgi_info;
meas_result_s_ meas_result;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultListCDMA2000 ::= SEQUENCE (SIZE (1..8)) OF MeasResultCDMA2000
using meas_result_list_cdma2000_l = dyn_array<meas_result_cdma2000_s>;
// MeasResultUTRA ::= SEQUENCE
struct meas_result_utra_s {
struct pci_c_ {
struct types_opts {
enum options { fdd, tdd, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
pci_c_() = default;
pci_c_(const pci_c_& other);
pci_c_& operator=(const pci_c_& other);
~pci_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
uint16_t& fdd()
{
assert_choice_type("fdd", type_.to_string(), "physCellId");
return c.get<uint16_t>();
}
uint8_t& tdd()
{
assert_choice_type("tdd", type_.to_string(), "physCellId");
return c.get<uint8_t>();
}
const uint16_t& fdd() const
{
assert_choice_type("fdd", type_.to_string(), "physCellId");
return c.get<uint16_t>();
}
const uint8_t& tdd() const
{
assert_choice_type("tdd", type_.to_string(), "physCellId");
return c.get<uint8_t>();
}
uint16_t& set_fdd()
{
set(types::fdd);
return c.get<uint16_t>();
}
uint8_t& set_tdd()
{
set(types::tdd);
return c.get<uint8_t>();
}
private:
types type_;
pod_choice_buffer_t c;
void destroy_();
};
struct cgi_info_s_ {
bool location_area_code_present = false;
bool routing_area_code_present = false;
bool plmn_id_list_present = false;
cell_global_id_utra_s cell_global_id;
fixed_bitstring<16> location_area_code;
fixed_bitstring<8> routing_area_code;
plmn_id_list2_l plmn_id_list;
};
struct meas_result_s_ {
bool ext = false;
bool utra_rscp_present = false;
bool utra_ec_n0_present = false;
int8_t utra_rscp = -5;
uint8_t utra_ec_n0 = 0;
// ...
// group 0
copy_ptr<add_si_info_r9_s> add_si_info_r9;
// group 1
bool primary_plmn_suitable_r12_present = false;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// member variables
bool cgi_info_present = false;
pci_c_ pci;
cgi_info_s_ cgi_info;
meas_result_s_ meas_result;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// PLMN-IdentityListNR-r15 ::= SEQUENCE (SIZE (1..12)) OF PLMN-Identity
using plmn_id_list_nr_r15_l = dyn_array<plmn_id_s>;
// DataBLER-MCH-ResultList-r12 ::= SEQUENCE (SIZE (1..15)) OF DataBLER-MCH-Result-r12
using data_bler_mch_result_list_r12_l = dyn_array<data_bler_mch_result_r12_s>;
// LocationInfo-r10 ::= SEQUENCE
struct location_info_r10_s {
struct location_coordinates_r10_c_ {
struct types_opts {
enum options {
ellipsoid_point_r10,
ellipsoid_point_with_altitude_r10,
// ...
ellipsoid_point_with_uncertainty_circle_r11,
ellipsoid_point_with_uncertainty_ellipse_r11,
ellipsoid_point_with_altitude_and_uncertainty_ellipsoid_r11,
ellipsoid_arc_r11,
polygon_r11,
nulltype
} value;
std::string to_string() const;
};
typedef enumerated<types_opts, true, 5> types;
// choice methods
location_coordinates_r10_c_() = default;
location_coordinates_r10_c_(const location_coordinates_r10_c_& other);
location_coordinates_r10_c_& operator=(const location_coordinates_r10_c_& other);
~location_coordinates_r10_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
dyn_octstring& ellipsoid_point_r10()
{
assert_choice_type("ellipsoid-Point-r10", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
dyn_octstring& ellipsoid_point_with_altitude_r10()
{
assert_choice_type("ellipsoidPointWithAltitude-r10", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
dyn_octstring& ellipsoid_point_with_uncertainty_circle_r11()
{
assert_choice_type("ellipsoidPointWithUncertaintyCircle-r11", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
dyn_octstring& ellipsoid_point_with_uncertainty_ellipse_r11()
{
assert_choice_type("ellipsoidPointWithUncertaintyEllipse-r11", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
dyn_octstring& ellipsoid_point_with_altitude_and_uncertainty_ellipsoid_r11()
{
assert_choice_type(
"ellipsoidPointWithAltitudeAndUncertaintyEllipsoid-r11", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
dyn_octstring& ellipsoid_arc_r11()
{
assert_choice_type("ellipsoidArc-r11", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
dyn_octstring& polygon_r11()
{
assert_choice_type("polygon-r11", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
const dyn_octstring& ellipsoid_point_r10() const
{
assert_choice_type("ellipsoid-Point-r10", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
const dyn_octstring& ellipsoid_point_with_altitude_r10() const
{
assert_choice_type("ellipsoidPointWithAltitude-r10", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
const dyn_octstring& ellipsoid_point_with_uncertainty_circle_r11() const
{
assert_choice_type("ellipsoidPointWithUncertaintyCircle-r11", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
const dyn_octstring& ellipsoid_point_with_uncertainty_ellipse_r11() const
{
assert_choice_type("ellipsoidPointWithUncertaintyEllipse-r11", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
const dyn_octstring& ellipsoid_point_with_altitude_and_uncertainty_ellipsoid_r11() const
{
assert_choice_type(
"ellipsoidPointWithAltitudeAndUncertaintyEllipsoid-r11", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
const dyn_octstring& ellipsoid_arc_r11() const
{
assert_choice_type("ellipsoidArc-r11", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
const dyn_octstring& polygon_r11() const
{
assert_choice_type("polygon-r11", type_.to_string(), "locationCoordinates-r10");
return c.get<dyn_octstring>();
}
dyn_octstring& set_ellipsoid_point_r10()
{
set(types::ellipsoid_point_r10);
return c.get<dyn_octstring>();
}
dyn_octstring& set_ellipsoid_point_with_altitude_r10()
{
set(types::ellipsoid_point_with_altitude_r10);
return c.get<dyn_octstring>();
}
dyn_octstring& set_ellipsoid_point_with_uncertainty_circle_r11()
{
set(types::ellipsoid_point_with_uncertainty_circle_r11);
return c.get<dyn_octstring>();
}
dyn_octstring& set_ellipsoid_point_with_uncertainty_ellipse_r11()
{
set(types::ellipsoid_point_with_uncertainty_ellipse_r11);
return c.get<dyn_octstring>();
}
dyn_octstring& set_ellipsoid_point_with_altitude_and_uncertainty_ellipsoid_r11()
{
set(types::ellipsoid_point_with_altitude_and_uncertainty_ellipsoid_r11);
return c.get<dyn_octstring>();
}
dyn_octstring& set_ellipsoid_arc_r11()
{
set(types::ellipsoid_arc_r11);
return c.get<dyn_octstring>();
}
dyn_octstring& set_polygon_r11()
{
set(types::polygon_r11);
return c.get<dyn_octstring>();
}
private:
types type_;
choice_buffer_t<dyn_octstring> c;
void destroy_();
};
struct vertical_velocity_info_r15_c_ {
struct types_opts {
enum options { vertical_velocity_r15, vertical_velocity_and_uncertainty_r15, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
vertical_velocity_info_r15_c_() = default;
vertical_velocity_info_r15_c_(const vertical_velocity_info_r15_c_& other);
vertical_velocity_info_r15_c_& operator=(const vertical_velocity_info_r15_c_& other);
~vertical_velocity_info_r15_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
dyn_octstring& vertical_velocity_r15()
{
assert_choice_type("verticalVelocity-r15", type_.to_string(), "verticalVelocityInfo-r15");
return c.get<dyn_octstring>();
}
dyn_octstring& vertical_velocity_and_uncertainty_r15()
{
assert_choice_type("verticalVelocityAndUncertainty-r15", type_.to_string(), "verticalVelocityInfo-r15");
return c.get<dyn_octstring>();
}
const dyn_octstring& vertical_velocity_r15() const
{
assert_choice_type("verticalVelocity-r15", type_.to_string(), "verticalVelocityInfo-r15");
return c.get<dyn_octstring>();
}
const dyn_octstring& vertical_velocity_and_uncertainty_r15() const
{
assert_choice_type("verticalVelocityAndUncertainty-r15", type_.to_string(), "verticalVelocityInfo-r15");
return c.get<dyn_octstring>();
}
dyn_octstring& set_vertical_velocity_r15()
{
set(types::vertical_velocity_r15);
return c.get<dyn_octstring>();
}
dyn_octstring& set_vertical_velocity_and_uncertainty_r15()
{
set(types::vertical_velocity_and_uncertainty_r15);
return c.get<dyn_octstring>();
}
private:
types type_;
choice_buffer_t<dyn_octstring> c;
void destroy_();
};
// member variables
bool ext = false;
bool horizontal_velocity_r10_present = false;
bool gnss_tod_msec_r10_present = false;
location_coordinates_r10_c_ location_coordinates_r10;
dyn_octstring horizontal_velocity_r10;
dyn_octstring gnss_tod_msec_r10;
// ...
// group 0
copy_ptr<vertical_velocity_info_r15_c_> vertical_velocity_info_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultGERAN ::= SEQUENCE
struct meas_result_geran_s {
struct cgi_info_s_ {
bool routing_area_code_present = false;
cell_global_id_geran_s cell_global_id;
fixed_bitstring<8> routing_area_code;
};
struct meas_result_s_ {
bool ext = false;
uint8_t rssi = 0;
// ...
};
// member variables
bool cgi_info_present = false;
carrier_freq_geran_s carrier_freq;
pci_geran_s pci;
cgi_info_s_ cgi_info;
meas_result_s_ meas_result;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultListEUTRA ::= SEQUENCE (SIZE (1..8)) OF MeasResultEUTRA
using meas_result_list_eutra_l = dyn_array<meas_result_eutra_s>;
// MeasResultListUTRA ::= SEQUENCE (SIZE (1..8)) OF MeasResultUTRA
using meas_result_list_utra_l = dyn_array<meas_result_utra_s>;
// MeasResultNR-r15 ::= SEQUENCE
struct meas_result_nr_r15_s {
bool ext = false;
bool rsrp_result_r15_present = false;
bool rsrq_result_r15_present = false;
bool rs_sinr_result_r15_present = false;
uint8_t rsrp_result_r15 = 0;
uint8_t rsrq_result_r15 = 0;
uint8_t rs_sinr_result_r15 = 0;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultsCDMA2000 ::= SEQUENCE
struct meas_results_cdma2000_s {
bool pre_regist_status_hrpd = false;
meas_result_list_cdma2000_l meas_result_list_cdma2000;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// PLMN-IdentityInfoNR-r15 ::= SEQUENCE
struct plmn_id_info_nr_r15_s {
bool tac_r15_present = false;
bool ran_area_code_r15_present = false;
plmn_id_list_nr_r15_l plmn_id_list_r15;
fixed_bitstring<24> tac_r15;
uint16_t ran_area_code_r15 = 0;
fixed_bitstring<36> cell_id_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// RSRQ-Type-r12 ::= SEQUENCE
struct rsrq_type_r12_s {
bool all_symbols_r12 = false;
bool wide_band_r12 = false;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// WLAN-RTT-r15 ::= SEQUENCE
struct wlan_rtt_r15_s {
struct rtt_units_r15_opts {
enum options {
microseconds,
hundredsofnanoseconds,
tensofnanoseconds,
nanoseconds,
tenthsofnanoseconds,
/*...*/ nulltype
} value;
std::string to_string() const;
};
typedef enumerated<rtt_units_r15_opts, true> rtt_units_r15_e_;
// member variables
bool ext = false;
bool rtt_accuracy_r15_present = false;
uint32_t rtt_value_r15 = 0;
rtt_units_r15_e_ rtt_units_r15;
uint16_t rtt_accuracy_r15 = 0;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// LogMeasResultBT-r15 ::= SEQUENCE
struct log_meas_result_bt_r15_s {
bool ext = false;
bool rssi_bt_r15_present = false;
fixed_bitstring<48> bt_addr_r15;
int16_t rssi_bt_r15 = -128;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// LogMeasResultWLAN-r15 ::= SEQUENCE
struct log_meas_result_wlan_r15_s {
bool ext = false;
bool rssi_wlan_r15_present = false;
bool rtt_wlan_r15_present = false;
wlan_ids_r12_s wlan_ids_r15;
uint8_t rssi_wlan_r15 = 0;
wlan_rtt_r15_s rtt_wlan_r15;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResult2CDMA2000-r9 ::= SEQUENCE
struct meas_result2_cdma2000_r9_s {
carrier_freq_cdma2000_s carrier_freq_r9;
meas_results_cdma2000_s meas_result_list_r9;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResult2EUTRA-r9 ::= SEQUENCE
struct meas_result2_eutra_r9_s {
uint32_t carrier_freq_r9 = 0;
meas_result_list_eutra_l meas_result_list_r9;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResult2EUTRA-v1250 ::= SEQUENCE
struct meas_result2_eutra_v1250_s {
bool rsrq_type_r12_present = false;
rsrq_type_r12_s rsrq_type_r12;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResult2EUTRA-v9e0 ::= SEQUENCE
struct meas_result2_eutra_v9e0_s {
bool carrier_freq_v9e0_present = false;
uint32_t carrier_freq_v9e0 = 65536;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResult2UTRA-r9 ::= SEQUENCE
struct meas_result2_utra_r9_s {
uint16_t carrier_freq_r9 = 0;
meas_result_list_utra_l meas_result_list_r9;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultListGERAN ::= SEQUENCE (SIZE (1..8)) OF MeasResultGERAN
using meas_result_list_geran_l = dyn_array<meas_result_geran_s>;
// MeasResultMBSFN-r12 ::= SEQUENCE
struct meas_result_mbsfn_r12_s {
struct mbsfn_area_r12_s_ {
uint16_t mbsfn_area_id_r12 = 0;
uint32_t carrier_freq_r12 = 0;
};
// member variables
bool ext = false;
bool sig_bler_result_r12_present = false;
bool data_bler_mch_result_list_r12_present = false;
mbsfn_area_r12_s_ mbsfn_area_r12;
uint8_t rsrp_result_mbsfn_r12 = 0;
uint8_t rsrq_result_mbsfn_r12 = 0;
bler_result_r12_s sig_bler_result_r12;
data_bler_mch_result_list_r12_l data_bler_mch_result_list_r12;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultSSB-Index-r15 ::= SEQUENCE
struct meas_result_ssb_idx_r15_s {
bool ext = false;
bool meas_result_ssb_idx_r15_present = false;
uint8_t ssb_idx_r15 = 0;
meas_result_nr_r15_s meas_result_ssb_idx_r15;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// PLMN-IdentityInfoListNR-r15 ::= SEQUENCE (SIZE (1..12)) OF PLMN-IdentityInfoNR-r15
using plmn_id_info_list_nr_r15_l = dyn_array<plmn_id_info_nr_r15_s>;
// CGI-InfoNR-r15 ::= SEQUENCE
struct cgi_info_nr_r15_s {
struct no_sib1_r15_s_ {
uint8_t ssb_subcarrier_offset_r15 = 0;
uint16_t pdcch_cfg_sib1_r15 = 0;
};
// member variables
update RRC ASN1 to 2020-09 v15.11
4 years ago
bool ext = false;
bool plmn_id_info_list_r15_present = false;
bool freq_band_list_r15_present = false;
bool no_sib1_r15_present = false;
update nr asn1 files, and asn1 tests
4 years ago
plmn_id_info_list_nr_r15_l plmn_id_info_list_r15;
update RRC ASN1 to 2020-09 v15.11
4 years ago
multi_freq_band_list_nr_r15_l freq_band_list_r15;
update nr asn1 files, and asn1 tests
4 years ago
no_sib1_r15_s_ no_sib1_r15;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// LogMeasResultListBT-r15 ::= SEQUENCE (SIZE (1..32)) OF LogMeasResultBT-r15
using log_meas_result_list_bt_r15_l = dyn_array<log_meas_result_bt_r15_s>;
// LogMeasResultListWLAN-r15 ::= SEQUENCE (SIZE (1..32)) OF LogMeasResultWLAN-r15
using log_meas_result_list_wlan_r15_l = dyn_array<log_meas_result_wlan_r15_s>;
// MeasResultList2CDMA2000-r9 ::= SEQUENCE (SIZE (1..8)) OF MeasResult2CDMA2000-r9
using meas_result_list2_cdma2000_r9_l = dyn_array<meas_result2_cdma2000_r9_s>;
// MeasResultList2EUTRA-r9 ::= SEQUENCE (SIZE (1..8)) OF MeasResult2EUTRA-r9
using meas_result_list2_eutra_r9_l = dyn_array<meas_result2_eutra_r9_s>;
// MeasResultList2EUTRA-v1250 ::= SEQUENCE (SIZE (1..8)) OF MeasResult2EUTRA-v1250
using meas_result_list2_eutra_v1250_l = dyn_array<meas_result2_eutra_v1250_s>;
// MeasResultList2EUTRA-v9e0 ::= SEQUENCE (SIZE (1..8)) OF MeasResult2EUTRA-v9e0
using meas_result_list2_eutra_v9e0_l = dyn_array<meas_result2_eutra_v9e0_s>;
// MeasResultList2GERAN-r10 ::= SEQUENCE (SIZE (1..3)) OF MeasResultListGERAN
using meas_result_list2_geran_r10_l = dyn_array<meas_result_list_geran_l>;
// MeasResultList2UTRA-r9 ::= SEQUENCE (SIZE (1..8)) OF MeasResult2UTRA-r9
using meas_result_list2_utra_r9_l = dyn_array<meas_result2_utra_r9_s>;
// MeasResultListMBSFN-r12 ::= SEQUENCE (SIZE (1..8)) OF MeasResultMBSFN-r12
using meas_result_list_mbsfn_r12_l = dyn_array<meas_result_mbsfn_r12_s>;
// MeasResultSSB-IndexList-r15 ::= SEQUENCE (SIZE (1..32)) OF MeasResultSSB-Index-r15
using meas_result_ssb_idx_list_r15_l = dyn_array<meas_result_ssb_idx_r15_s>;
// LogMeasInfo-r10 ::= SEQUENCE
struct log_meas_info_r10_s {
struct meas_result_serv_cell_r10_s_ {
uint8_t rsrp_result_r10 = 0;
uint8_t rsrq_result_r10 = 0;
};
struct meas_result_neigh_cells_r10_s_ {
bool meas_result_list_eutra_r10_present = false;
bool meas_result_list_utra_r10_present = false;
bool meas_result_list_geran_r10_present = false;
bool meas_result_list_cdma2000_r10_present = false;
meas_result_list2_eutra_r9_l meas_result_list_eutra_r10;
meas_result_list2_utra_r9_l meas_result_list_utra_r10;
meas_result_list2_geran_r10_l meas_result_list_geran_r10;
meas_result_list2_cdma2000_r9_l meas_result_list_cdma2000_r10;
};
// member variables
bool ext = false;
bool location_info_r10_present = false;
bool meas_result_neigh_cells_r10_present = false;
location_info_r10_s location_info_r10;
uint16_t relative_time_stamp_r10 = 0;
cell_global_id_eutra_s serv_cell_id_r10;
meas_result_serv_cell_r10_s_ meas_result_serv_cell_r10;
meas_result_neigh_cells_r10_s_ meas_result_neigh_cells_r10;
// ...
// group 0
copy_ptr<meas_result_list2_eutra_v9e0_l> meas_result_list_eutra_v1090;
// group 1
bool meas_result_serv_cell_v1250_present = false;
copy_ptr<meas_result_list_mbsfn_r12_l> meas_result_list_mbsfn_r12;
int8_t meas_result_serv_cell_v1250 = -30;
copy_ptr<rsrq_type_r12_s> serv_cell_rsrq_type_r12;
copy_ptr<meas_result_list2_eutra_v1250_l> meas_result_list_eutra_v1250;
// group 2
bool in_dev_coex_detected_r13_present = false;
// group 3
bool meas_result_serv_cell_v1360_present = false;
int8_t meas_result_serv_cell_v1360 = -17;
// group 4
copy_ptr<log_meas_result_list_bt_r15_l> log_meas_result_list_bt_r15;
copy_ptr<log_meas_result_list_wlan_r15_l> log_meas_result_list_wlan_r15;
// group 5
bool any_cell_sel_detected_r15_present = false;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultCellNR-r15 ::= SEQUENCE
struct meas_result_cell_nr_r15_s {
bool ext = false;
bool meas_result_rs_idx_list_r15_present = false;
uint16_t pci_r15 = 0;
meas_result_nr_r15_s meas_result_cell_r15;
meas_result_ssb_idx_list_r15_l meas_result_rs_idx_list_r15;
// ...
// group 0
copy_ptr<cgi_info_nr_r15_s> cgi_info_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// LogMeasInfoList-r10 ::= SEQUENCE (SIZE (1..520)) OF LogMeasInfo-r10
using log_meas_info_list_r10_l = dyn_array<log_meas_info_r10_s>;
// MeasResultCellListNR-r15 ::= SEQUENCE (SIZE (1..8)) OF MeasResultCellNR-r15
using meas_result_cell_list_nr_r15_l = dyn_array<meas_result_cell_nr_r15_s>;
// LogMeasReport-r10 ::= SEQUENCE
struct log_meas_report_r10_s {
bool ext = false;
bool log_meas_available_r10_present = false;
fixed_bitstring<48> absolute_time_stamp_r10;
trace_ref_r10_s trace_ref_r10;
fixed_octstring<2> trace_recording_session_ref_r10;
fixed_octstring<1> tce_id_r10;
log_meas_info_list_r10_l log_meas_info_list_r10;
// ...
// group 0
bool log_meas_available_bt_r15_present = false;
bool log_meas_available_wlan_r15_present = false;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultCBR-r14 ::= SEQUENCE
struct meas_result_cbr_r14_s {
bool cbr_pscch_r14_present = false;
uint8_t pool_id_r14 = 1;
uint8_t cbr_pssch_r14 = 0;
uint8_t cbr_pscch_r14 = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultCSI-RS-r12 ::= SEQUENCE
struct meas_result_csi_rs_r12_s {
bool ext = false;
uint8_t meas_csi_rs_id_r12 = 1;
uint8_t csi_rsrp_result_r12 = 0;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultCellSFTD-r15 ::= SEQUENCE
struct meas_result_cell_sftd_r15_s {
bool rsrp_result_r15_present = false;
uint16_t pci_r15 = 0;
uint16_t sfn_offset_result_r15 = 0;
int16_t frame_boundary_offset_result_r15 = -30720;
uint8_t rsrp_result_r15 = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultServFreq-r10 ::= SEQUENCE
struct meas_result_serv_freq_r10_s {
struct meas_result_scell_r10_s_ {
uint8_t rsrp_result_scell_r10 = 0;
uint8_t rsrq_result_scell_r10 = 0;
};
struct meas_result_best_neigh_cell_r10_s_ {
uint16_t pci_r10 = 0;
uint8_t rsrp_result_ncell_r10 = 0;
uint8_t rsrq_result_ncell_r10 = 0;
};
struct meas_result_scell_v1310_s_ {
uint8_t rs_sinr_result_r13 = 0;
};
struct meas_result_best_neigh_cell_v1310_s_ {
uint8_t rs_sinr_result_r13 = 0;
};
// member variables
bool ext = false;
bool meas_result_scell_r10_present = false;
bool meas_result_best_neigh_cell_r10_present = false;
uint8_t serv_freq_id_r10 = 0;
meas_result_scell_r10_s_ meas_result_scell_r10;
meas_result_best_neigh_cell_r10_s_ meas_result_best_neigh_cell_r10;
// ...
// group 0
bool meas_result_scell_v1250_present = false;
bool meas_result_best_neigh_cell_v1250_present = false;
int8_t meas_result_scell_v1250 = -30;
int8_t meas_result_best_neigh_cell_v1250 = -30;
// group 1
copy_ptr<meas_result_scell_v1310_s_> meas_result_scell_v1310;
copy_ptr<meas_result_best_neigh_cell_v1310_s_> meas_result_best_neigh_cell_v1310;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultServFreq-r13 ::= SEQUENCE
struct meas_result_serv_freq_r13_s {
struct meas_result_scell_r13_s_ {
bool rs_sinr_result_r13_present = false;
uint8_t rsrp_result_scell_r13 = 0;
int8_t rsrq_result_scell_r13 = -30;
uint8_t rs_sinr_result_r13 = 0;
};
struct meas_result_best_neigh_cell_r13_s_ {
bool rs_sinr_result_r13_present = false;
uint16_t pci_r13 = 0;
uint8_t rsrp_result_ncell_r13 = 0;
int8_t rsrq_result_ncell_r13 = -30;
uint8_t rs_sinr_result_r13 = 0;
};
struct meas_result_best_neigh_cell_v1360_s_ {
int8_t rsrp_result_ncell_v1360 = -17;
};
// member variables
bool ext = false;
bool meas_result_scell_r13_present = false;
bool meas_result_best_neigh_cell_r13_present = false;
uint8_t serv_freq_id_r13 = 0;
meas_result_scell_r13_s_ meas_result_scell_r13;
meas_result_best_neigh_cell_r13_s_ meas_result_best_neigh_cell_r13;
// ...
// group 0
copy_ptr<meas_result_best_neigh_cell_v1360_s_> meas_result_best_neigh_cell_v1360;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultServFreqNR-r15 ::= SEQUENCE
struct meas_result_serv_freq_nr_r15_s {
bool ext = false;
bool meas_result_scell_r15_present = false;
bool meas_result_best_neigh_cell_r15_present = false;
uint32_t carrier_freq_r15 = 0;
meas_result_cell_nr_r15_s meas_result_scell_r15;
meas_result_cell_nr_r15_s meas_result_best_neigh_cell_r15;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultWLAN-r13 ::= SEQUENCE
struct meas_result_wlan_r13_s {
bool ext = false;
bool carrier_info_wlan_r13_present = false;
bool band_wlan_r13_present = false;
bool available_admission_capacity_wlan_r13_present = false;
bool backhaul_dl_bw_wlan_r13_present = false;
bool backhaul_ul_bw_wlan_r13_present = false;
bool ch_utilization_wlan_r13_present = false;
bool station_count_wlan_r13_present = false;
bool connected_wlan_r13_present = false;
wlan_ids_r12_s wlan_ids_r13;
wlan_carrier_info_r13_s carrier_info_wlan_r13;
wlan_band_ind_r13_e band_wlan_r13;
uint8_t rssi_wlan_r13 = 0;
uint16_t available_admission_capacity_wlan_r13 = 0;
wlan_backhaul_rate_r12_e backhaul_dl_bw_wlan_r13;
wlan_backhaul_rate_r12_e backhaul_ul_bw_wlan_r13;
uint16_t ch_utilization_wlan_r13 = 0;
uint32_t station_count_wlan_r13 = 0;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// SensingResult-r15 ::= SEQUENCE
struct sensing_result_r15_s {
uint16_t res_idx_r15 = 1;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// UL-PDCP-DelayResult-r13 ::= SEQUENCE
struct ul_pdcp_delay_result_r13_s {
struct qci_id_r13_opts {
enum options { qci1, qci2, qci3, qci4, spare4, spare3, spare2, spare1, nulltype } value;
typedef uint8_t number_type;
std::string to_string() const;
uint8_t to_number() const;
};
typedef enumerated<qci_id_r13_opts> qci_id_r13_e_;
// member variables
bool ext = false;
qci_id_r13_e_ qci_id_r13;
uint8_t excess_delay_r13 = 0;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultCSI-RS-List-r12 ::= SEQUENCE (SIZE (1..8)) OF MeasResultCSI-RS-r12
using meas_result_csi_rs_list_r12_l = dyn_array<meas_result_csi_rs_r12_s>;
// MeasResultCellListSFTD-r15 ::= SEQUENCE (SIZE (1..3)) OF MeasResultCellSFTD-r15
using meas_result_cell_list_sftd_r15_l = dyn_array<meas_result_cell_sftd_r15_s>;
// MeasResultForECID-r9 ::= SEQUENCE
struct meas_result_for_ecid_r9_s {
uint16_t ue_rx_tx_time_diff_result_r9 = 0;
fixed_bitstring<10> current_sfn_r9;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultForRSSI-r13 ::= SEQUENCE
struct meas_result_for_rssi_r13_s {
bool ext = false;
uint8_t rssi_result_r13 = 0;
uint8_t ch_occupancy_r13 = 0;
// ...
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultListCBR-r14 ::= SEQUENCE (SIZE (1..72)) OF MeasResultCBR-r14
using meas_result_list_cbr_r14_l = dyn_array<meas_result_cbr_r14_s>;
// MeasResultListWLAN-r13 ::= SEQUENCE (SIZE (1..8)) OF MeasResultWLAN-r13
using meas_result_list_wlan_r13_l = dyn_array<meas_result_wlan_r13_s>;
// MeasResultListWLAN-r14 ::= SEQUENCE (SIZE (1..32)) OF MeasResultWLAN-r13
using meas_result_list_wlan_r14_l = dyn_array<meas_result_wlan_r13_s>;
// MeasResultSSTD-r13 ::= SEQUENCE
struct meas_result_sstd_r13_s {
uint16_t sfn_offset_result_r13 = 0;
int8_t frame_boundary_offset_result_r13 = -5;
uint8_t sf_boundary_offset_result_r13 = 0;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultSensing-r15 ::= SEQUENCE
struct meas_result_sensing_r15_s {
using sensing_result_r15_l_ = dyn_array<sensing_result_r15_s>;
// member variables
uint16_t sl_sf_ref_r15 = 0;
sensing_result_r15_l_ sensing_result_r15;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasResultServFreqList-r10 ::= SEQUENCE (SIZE (1..5)) OF MeasResultServFreq-r10
using meas_result_serv_freq_list_r10_l = dyn_array<meas_result_serv_freq_r10_s>;
// MeasResultServFreqListExt-r13 ::= SEQUENCE (SIZE (1..32)) OF MeasResultServFreq-r13
using meas_result_serv_freq_list_ext_r13_l = dyn_array<meas_result_serv_freq_r13_s>;
// MeasResultServFreqListNR-r15 ::= SEQUENCE (SIZE (1..32)) OF MeasResultServFreqNR-r15
using meas_result_serv_freq_list_nr_r15_l = dyn_array<meas_result_serv_freq_nr_r15_s>;
// UL-PDCP-DelayResultList-r13 ::= SEQUENCE (SIZE (1..6)) OF UL-PDCP-DelayResult-r13
using ul_pdcp_delay_result_list_r13_l = dyn_array<ul_pdcp_delay_result_r13_s>;
// MeasResults ::= SEQUENCE
struct meas_results_s {
struct meas_result_pcell_s_ {
uint8_t rsrp_result = 0;
uint8_t rsrq_result = 0;
};
struct meas_result_neigh_cells_c_ {
struct types_opts {
enum options {
meas_result_list_eutra,
meas_result_list_utra,
meas_result_list_geran,
meas_results_cdma2000,
// ...
meas_result_neigh_cell_list_nr_r15,
nulltype
} value;
typedef uint16_t number_type;
std::string to_string() const;
uint16_t to_number() const;
};
typedef enumerated<types_opts, true, 1> types;
// choice methods
meas_result_neigh_cells_c_() = default;
meas_result_neigh_cells_c_(const meas_result_neigh_cells_c_& other);
meas_result_neigh_cells_c_& operator=(const meas_result_neigh_cells_c_& other);
~meas_result_neigh_cells_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
meas_result_list_eutra_l& meas_result_list_eutra()
{
assert_choice_type("measResultListEUTRA", type_.to_string(), "measResultNeighCells");
return c.get<meas_result_list_eutra_l>();
}
meas_result_list_utra_l& meas_result_list_utra()
{
assert_choice_type("measResultListUTRA", type_.to_string(), "measResultNeighCells");
return c.get<meas_result_list_utra_l>();
}
meas_result_list_geran_l& meas_result_list_geran()
{
assert_choice_type("measResultListGERAN", type_.to_string(), "measResultNeighCells");
return c.get<meas_result_list_geran_l>();
}
meas_results_cdma2000_s& meas_results_cdma2000()
{
assert_choice_type("measResultsCDMA2000", type_.to_string(), "measResultNeighCells");
return c.get<meas_results_cdma2000_s>();
}
meas_result_cell_list_nr_r15_l& meas_result_neigh_cell_list_nr_r15()
{
assert_choice_type("measResultNeighCellListNR-r15", type_.to_string(), "measResultNeighCells");
return c.get<meas_result_cell_list_nr_r15_l>();
}
const meas_result_list_eutra_l& meas_result_list_eutra() const
{
assert_choice_type("measResultListEUTRA", type_.to_string(), "measResultNeighCells");
return c.get<meas_result_list_eutra_l>();
}
const meas_result_list_utra_l& meas_result_list_utra() const
{
assert_choice_type("measResultListUTRA", type_.to_string(), "measResultNeighCells");
return c.get<meas_result_list_utra_l>();
}
const meas_result_list_geran_l& meas_result_list_geran() const
{
assert_choice_type("measResultListGERAN", type_.to_string(), "measResultNeighCells");
return c.get<meas_result_list_geran_l>();
}
const meas_results_cdma2000_s& meas_results_cdma2000() const
{
assert_choice_type("measResultsCDMA2000", type_.to_string(), "measResultNeighCells");
return c.get<meas_results_cdma2000_s>();
}
const meas_result_cell_list_nr_r15_l& meas_result_neigh_cell_list_nr_r15() const
{
assert_choice_type("measResultNeighCellListNR-r15", type_.to_string(), "measResultNeighCells");
return c.get<meas_result_cell_list_nr_r15_l>();
}
meas_result_list_eutra_l& set_meas_result_list_eutra()
{
set(types::meas_result_list_eutra);
return c.get<meas_result_list_eutra_l>();
}
meas_result_list_utra_l& set_meas_result_list_utra()
{
set(types::meas_result_list_utra);
return c.get<meas_result_list_utra_l>();
}
meas_result_list_geran_l& set_meas_result_list_geran()
{
set(types::meas_result_list_geran);
return c.get<meas_result_list_geran_l>();
}
meas_results_cdma2000_s& set_meas_results_cdma2000()
{
set(types::meas_results_cdma2000);
return c.get<meas_results_cdma2000_s>();
}
meas_result_cell_list_nr_r15_l& set_meas_result_neigh_cell_list_nr_r15()
{
set(types::meas_result_neigh_cell_list_nr_r15);
return c.get<meas_result_cell_list_nr_r15_l>();
}
private:
types type_;
choice_buffer_t<meas_result_cell_list_nr_r15_l,
meas_result_list_eutra_l,
meas_result_list_geran_l,
meas_result_list_utra_l,
meas_results_cdma2000_s>
c;
void destroy_();
};
struct meas_result_pcell_v1310_s_ {
uint8_t rs_sinr_result_r13 = 0;
};
// member variables
bool ext = false;
bool meas_result_neigh_cells_present = false;
uint8_t meas_id = 1;
meas_result_pcell_s_ meas_result_pcell;
meas_result_neigh_cells_c_ meas_result_neigh_cells;
// ...
// group 0
copy_ptr<meas_result_for_ecid_r9_s> meas_result_for_ecid_r9;
// group 1
copy_ptr<location_info_r10_s> location_info_r10;
copy_ptr<meas_result_serv_freq_list_r10_l> meas_result_serv_freq_list_r10;
// group 2
bool meas_id_v1250_present = false;
bool meas_result_pcell_v1250_present = false;
uint8_t meas_id_v1250 = 33;
int8_t meas_result_pcell_v1250 = -30;
copy_ptr<meas_result_csi_rs_list_r12_l> meas_result_csi_rs_list_r12;
// group 3
copy_ptr<meas_result_for_rssi_r13_s> meas_result_for_rssi_r13;
copy_ptr<meas_result_serv_freq_list_ext_r13_l> meas_result_serv_freq_list_ext_r13;
copy_ptr<meas_result_sstd_r13_s> meas_result_sstd_r13;
copy_ptr<meas_result_pcell_v1310_s_> meas_result_pcell_v1310;
copy_ptr<ul_pdcp_delay_result_list_r13_l> ul_pdcp_delay_result_list_r13;
copy_ptr<meas_result_list_wlan_r13_l> meas_result_list_wlan_r13;
// group 4
bool meas_result_pcell_v1360_present = false;
int8_t meas_result_pcell_v1360 = -17;
// group 5
copy_ptr<meas_result_list_cbr_r14_l> meas_result_list_cbr_r14;
copy_ptr<meas_result_list_wlan_r14_l> meas_result_list_wlan_r14;
// group 6
copy_ptr<meas_result_serv_freq_list_nr_r15_l> meas_result_serv_freq_list_nr_r15;
copy_ptr<meas_result_cell_list_sftd_r15_l> meas_result_cell_list_sftd_r15;
// group 7
bool height_ue_r15_present = false;
copy_ptr<log_meas_result_list_bt_r15_l> log_meas_result_list_bt_r15;
copy_ptr<log_meas_result_list_wlan_r15_l> log_meas_result_list_wlan_r15;
copy_ptr<meas_result_sensing_r15_s> meas_result_sensing_r15;
int16_t height_ue_r15 = -400;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasurementReport-v8a0-IEs ::= SEQUENCE
struct meas_report_v8a0_ies_s {
bool late_non_crit_ext_present = false;
bool non_crit_ext_present = false;
dyn_octstring late_non_crit_ext;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasurementReport-r8-IEs ::= SEQUENCE
struct meas_report_r8_ies_s {
bool non_crit_ext_present = false;
meas_results_s meas_results;
meas_report_v8a0_ies_s non_crit_ext;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
// MeasurementReport ::= SEQUENCE
struct meas_report_s {
struct crit_exts_c_ {
struct c1_c_ {
struct types_opts {
enum options { meas_report_r8, spare7, spare6, spare5, spare4, spare3, spare2, spare1, nulltype } value;
std::string to_string() const;
};
typedef enumerated<types_opts> types;
// choice methods
c1_c_() = default;
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
meas_report_r8_ies_s& meas_report_r8()
{
assert_choice_type("measurementReport-r8", type_.to_string(), "c1");
return c;
}
const meas_report_r8_ies_s& meas_report_r8() const
{
assert_choice_type("measurementReport-r8", type_.to_string(), "c1");
return c;
}
meas_report_r8_ies_s& set_meas_report_r8()
{
set(types::meas_report_r8);
return c;
}
private:
types type_;
meas_report_r8_ies_s c;
};
typedef c1_or_crit_ext_e types;
// choice methods
crit_exts_c_() = default;
crit_exts_c_(const crit_exts_c_& other);
crit_exts_c_& operator=(const crit_exts_c_& other);
~crit_exts_c_() { destroy_(); }
void set(types::options e = types::nulltype);
types type() const { return type_; }
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
return c.get<c1_c_>();
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
return c.get<c1_c_>();
}
c1_c_& set_c1()
{
set(types::c1);
return c.get<c1_c_>();
}
private:
types type_;
choice_buffer_t<c1_c_> c;
void destroy_();
};
// member variables
crit_exts_c_ crit_exts;
// sequence methods
SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack(cbit_ref& bref);
void to_json(json_writer& j) const;
};
} // namespace rrc
} // namespace asn1
#endif // SRSASN1_RRC_MEASCFG_H