5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

asn1 fix - fix choice access correct type assert

Browse Source
master
Francisco 4 years ago committed by Francisco Paisana
parent ff3fc0826b
commit 289559af82
25 changed files with 5824 additions and 5821 deletions
Show Stats Download Patch File Download Diff File

12
lib/include/srsran/asn1/asn1_utils.h
Unescape Escape View File

@ -13,6 +13,7 @@
#ifndef SRSASN_COMMON_UTILS_H
#define SRSASN_COMMON_UTILS_H
#include "srsran/common/srsran_assert.h"
#include "srsran/srslog/srslog.h"
#include <algorithm>
#include <array>
@ -82,7 +83,16 @@ void log_invalid_access_choice_id(uint32_t val, uint32_t choice_id);
void log_invalid_choice_id(uint32_t val, const char* choice_type);
void invalid_enum_number(int value, const char* name);
void assert_choice_type(uint32_t val, uint32_t choice_id);
void assert_choice_type(const char* access_type, const char* current_type, const char* choice_type);
template <typename Enumerated>
void assert_choice_type(typename Enumerated::options access_type, Enumerated& current_type, const char* choice_type)
{
if (srsran_unlikely(current_type.value != access_type)) {
log_error("Invalid field access for choice type \"%s\" (\"%s\"!=\"%s\")",
choice_type,
Enumerated(access_type).to_string(),
current_type.to_string());
}
}
/************************
error handling

372
lib/include/srsran/asn1/ngap.h
View File

File diff suppressed because it is too large Load Diff

224
lib/include/srsran/asn1/rrc.h
Unescape Escape View File

@ -96,22 +96,22 @@ struct bcch_dl_sch_msg_type_mbms_r14_c {
// getters
sys_info_mbms_r14_s& sys_info_mbms_r14()
{
assert_choice_type("systemInformation-MBMS-r14", type_.to_string(), "c1");
assert_choice_type(types::sys_info_mbms_r14, type_, "c1");
return c.get<sys_info_mbms_r14_s>();
}
sib_type1_mbms_r14_s& sib_type1_mbms_r14()
{
assert_choice_type("systemInformationBlockType1-MBMS-r14", type_.to_string(), "c1");
assert_choice_type(types::sib_type1_mbms_r14, type_, "c1");
return c.get<sib_type1_mbms_r14_s>();
}
const sys_info_mbms_r14_s& sys_info_mbms_r14() const
{
assert_choice_type("systemInformation-MBMS-r14", type_.to_string(), "c1");
assert_choice_type(types::sys_info_mbms_r14, type_, "c1");
return c.get<sys_info_mbms_r14_s>();
}
const sib_type1_mbms_r14_s& sib_type1_mbms_r14() const
{
assert_choice_type("systemInformationBlockType1-MBMS-r14", type_.to_string(), "c1");
assert_choice_type(types::sib_type1_mbms_r14, type_, "c1");
return c.get<sib_type1_mbms_r14_s>();
}
sys_info_mbms_r14_s& set_sys_info_mbms_r14();
@ -142,12 +142,12 @@ struct bcch_dl_sch_msg_type_mbms_r14_c {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "BCCH-DL-SCH-MessageType-MBMS-r14");
assert_choice_type(types::c1, type_, "BCCH-DL-SCH-MessageType-MBMS-r14");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "BCCH-DL-SCH-MessageType-MBMS-r14");
assert_choice_type(types::c1, type_, "BCCH-DL-SCH-MessageType-MBMS-r14");
return c;
}
c1_c_& set_c1();
@ -212,22 +212,22 @@ struct pmch_cfg_r12_s {
// getters
uint8_t& normal_r12()
{
assert_choice_type("normal-r12", type_.to_string(), "dataMCS-r12");
assert_choice_type(types::normal_r12, type_, "dataMCS-r12");
return c.get<uint8_t>();
}
uint8_t& higer_order_r12()
{
assert_choice_type("higerOrder-r12", type_.to_string(), "dataMCS-r12");
assert_choice_type(types::higer_order_r12, type_, "dataMCS-r12");
return c.get<uint8_t>();
}
const uint8_t& normal_r12() const
{
assert_choice_type("normal-r12", type_.to_string(), "dataMCS-r12");
assert_choice_type(types::normal_r12, type_, "dataMCS-r12");
return c.get<uint8_t>();
}
const uint8_t& higer_order_r12() const
{
assert_choice_type("higerOrder-r12", type_.to_string(), "dataMCS-r12");
assert_choice_type(types::higer_order_r12, type_, "dataMCS-r12");
return c.get<uint8_t>();
}
uint8_t& set_normal_r12();
@ -485,12 +485,12 @@ struct mcch_msg_type_c {
// getters
c2_c_& c2()
{
assert_choice_type("c2", type_.to_string(), "later");
assert_choice_type(types::c2, type_, "later");
return c;
}
const c2_c_& c2() const
{
assert_choice_type("c2", type_.to_string(), "later");
assert_choice_type(types::c2, type_, "later");
return c;
}
c2_c_& set_c2();
@ -522,22 +522,22 @@ struct mcch_msg_type_c {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "MCCH-MessageType");
assert_choice_type(types::c1, type_, "MCCH-MessageType");
return c.get<c1_c_>();
}
later_c_& later()
{
assert_choice_type("later", type_.to_string(), "MCCH-MessageType");
assert_choice_type(types::later, type_, "MCCH-MessageType");
return c.get<later_c_>();
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "MCCH-MessageType");
assert_choice_type(types::c1, type_, "MCCH-MessageType");
return c.get<c1_c_>();
}
const later_c_& later() const
{
assert_choice_type("later", type_.to_string(), "MCCH-MessageType");
assert_choice_type(types::later, type_, "MCCH-MessageType");
return c.get<later_c_>();
}
c1_c_& set_c1();
@ -649,162 +649,162 @@ struct sc_mtch_sched_info_br_r14_s {
// getters
uint8_t& sf10()
{
assert_choice_type("sf10", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf10, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
uint8_t& sf20()
{
assert_choice_type("sf20", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf20, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
uint8_t& sf32()
{
assert_choice_type("sf32", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf32, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
uint8_t& sf40()
{
assert_choice_type("sf40", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf40, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
uint8_t& sf64()
{
assert_choice_type("sf64", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf64, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
uint8_t& sf80()
{
assert_choice_type("sf80", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf80, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
uint8_t& sf128()
{
assert_choice_type("sf128", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf128, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
uint8_t& sf160()
{
assert_choice_type("sf160", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf160, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
uint16_t& sf256()
{
assert_choice_type("sf256", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf256, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
uint16_t& sf320()
{
assert_choice_type("sf320", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf320, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
uint16_t& sf512()
{
assert_choice_type("sf512", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf512, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
uint16_t& sf640()
{
assert_choice_type("sf640", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf640, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
uint16_t& sf1024()
{
assert_choice_type("sf1024", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf1024, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
uint16_t& sf2048()
{
assert_choice_type("sf2048", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf2048, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
uint16_t& sf4096()
{
assert_choice_type("sf4096", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf4096, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
uint16_t& sf8192()
{
assert_choice_type("sf8192", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf8192, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
const uint8_t& sf10() const
{
assert_choice_type("sf10", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf10, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
const uint8_t& sf20() const
{
assert_choice_type("sf20", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf20, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
const uint8_t& sf32() const
{
assert_choice_type("sf32", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf32, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
const uint8_t& sf40() const
{
assert_choice_type("sf40", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf40, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
const uint8_t& sf64() const
{
assert_choice_type("sf64", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf64, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
const uint8_t& sf80() const
{
assert_choice_type("sf80", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf80, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
const uint8_t& sf128() const
{
assert_choice_type("sf128", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf128, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
const uint8_t& sf160() const
{
assert_choice_type("sf160", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf160, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint8_t>();
}
const uint16_t& sf256() const
{
assert_choice_type("sf256", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf256, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
const uint16_t& sf320() const
{
assert_choice_type("sf320", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf320, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
const uint16_t& sf512() const
{
assert_choice_type("sf512", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf512, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
const uint16_t& sf640() const
{
assert_choice_type("sf640", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf640, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
const uint16_t& sf1024() const
{
assert_choice_type("sf1024", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf1024, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
const uint16_t& sf2048() const
{
assert_choice_type("sf2048", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf2048, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
const uint16_t& sf4096() const
{
assert_choice_type("sf4096", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf4096, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
const uint16_t& sf8192() const
{
assert_choice_type("sf8192", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r14");
assert_choice_type(types::sf8192, type_, "schedulingPeriodStartOffsetSCPTM-r14");
return c.get<uint16_t>();
}
uint8_t& set_sf10();
@ -939,162 +939,162 @@ struct sc_mtch_sched_info_r13_s {
// getters
uint8_t& sf10()
{
assert_choice_type("sf10", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf10, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
uint8_t& sf20()
{
assert_choice_type("sf20", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf20, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
uint8_t& sf32()
{
assert_choice_type("sf32", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf32, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
uint8_t& sf40()
{
assert_choice_type("sf40", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf40, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
uint8_t& sf64()
{
assert_choice_type("sf64", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf64, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
uint8_t& sf80()
{
assert_choice_type("sf80", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf80, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
uint8_t& sf128()
{
assert_choice_type("sf128", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf128, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
uint8_t& sf160()
{
assert_choice_type("sf160", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf160, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
uint16_t& sf256()
{
assert_choice_type("sf256", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf256, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
uint16_t& sf320()
{
assert_choice_type("sf320", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf320, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
uint16_t& sf512()
{
assert_choice_type("sf512", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf512, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
uint16_t& sf640()
{
assert_choice_type("sf640", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf640, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
uint16_t& sf1024()
{
assert_choice_type("sf1024", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf1024, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
uint16_t& sf2048()
{
assert_choice_type("sf2048", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf2048, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
uint16_t& sf4096()
{
assert_choice_type("sf4096", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf4096, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
uint16_t& sf8192()
{
assert_choice_type("sf8192", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf8192, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
const uint8_t& sf10() const
{
assert_choice_type("sf10", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf10, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
const uint8_t& sf20() const
{
assert_choice_type("sf20", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf20, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
const uint8_t& sf32() const
{
assert_choice_type("sf32", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf32, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
const uint8_t& sf40() const
{
assert_choice_type("sf40", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf40, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
const uint8_t& sf64() const
{
assert_choice_type("sf64", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf64, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
const uint8_t& sf80() const
{
assert_choice_type("sf80", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf80, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
const uint8_t& sf128() const
{
assert_choice_type("sf128", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf128, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
const uint8_t& sf160() const
{
assert_choice_type("sf160", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf160, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint8_t>();
}
const uint16_t& sf256() const
{
assert_choice_type("sf256", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf256, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
const uint16_t& sf320() const
{
assert_choice_type("sf320", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf320, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
const uint16_t& sf512() const
{
assert_choice_type("sf512", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf512, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
const uint16_t& sf640() const
{
assert_choice_type("sf640", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf640, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
const uint16_t& sf1024() const
{
assert_choice_type("sf1024", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf1024, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
const uint16_t& sf2048() const
{
assert_choice_type("sf2048", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf2048, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
const uint16_t& sf4096() const
{
assert_choice_type("sf4096", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf4096, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
const uint16_t& sf8192() const
{
assert_choice_type("sf8192", type_.to_string(), "schedulingPeriodStartOffsetSCPTM-r13");
assert_choice_type(types::sf8192, type_, "schedulingPeriodStartOffsetSCPTM-r13");
return c.get<uint16_t>();
}
uint8_t& set_sf10();
@ -1194,22 +1194,22 @@ struct sc_mtch_info_br_r14_s {
// getters
fdd_r14_e_& fdd_r14()
{
assert_choice_type("fdd-r14", type_.to_string(), "mpdcch-StartSF-SC-MTCH-r14");
assert_choice_type(types::fdd_r14, type_, "mpdcch-StartSF-SC-MTCH-r14");
return c.get<fdd_r14_e_>();
}
tdd_r14_e_& tdd_r14()
{
assert_choice_type("tdd-r14", type_.to_string(), "mpdcch-StartSF-SC-MTCH-r14");
assert_choice_type(types::tdd_r14, type_, "mpdcch-StartSF-SC-MTCH-r14");
return c.get<tdd_r14_e_>();
}
const fdd_r14_e_& fdd_r14() const
{
assert_choice_type("fdd-r14", type_.to_string(), "mpdcch-StartSF-SC-MTCH-r14");
assert_choice_type(types::fdd_r14, type_, "mpdcch-StartSF-SC-MTCH-r14");
return c.get<fdd_r14_e_>();
}
const tdd_r14_e_& tdd_r14() const
{
assert_choice_type("tdd-r14", type_.to_string(), "mpdcch-StartSF-SC-MTCH-r14");
assert_choice_type(types::tdd_r14, type_, "mpdcch-StartSF-SC-MTCH-r14");
return c.get<tdd_r14_e_>();
}
fdd_r14_e_& set_fdd_r14();
@ -1423,12 +1423,12 @@ struct sc_mcch_msg_type_r13_c {
// getters
scptm_cfg_br_r14_s& scptm_cfg_br_r14()
{
assert_choice_type("scptmConfiguration-BR-r14", type_.to_string(), "c2");
assert_choice_type(types::scptm_cfg_br_r14, type_, "c2");
return c;
}
const scptm_cfg_br_r14_s& scptm_cfg_br_r14() const
{
assert_choice_type("scptmConfiguration-BR-r14", type_.to_string(), "c2");
assert_choice_type(types::scptm_cfg_br_r14, type_, "c2");
return c;
}
scptm_cfg_br_r14_s& set_scptm_cfg_br_r14();
@ -1457,12 +1457,12 @@ struct sc_mcch_msg_type_r13_c {
// getters
c2_c_& c2()
{
assert_choice_type("c2", type_.to_string(), "messageClassExtension");
assert_choice_type(types::c2, type_, "messageClassExtension");
return c;
}
const c2_c_& c2() const
{
assert_choice_type("c2", type_.to_string(), "messageClassExtension");
assert_choice_type(types::c2, type_, "messageClassExtension");
return c;
}
c2_c_& set_c2();
@ -1494,22 +1494,22 @@ struct sc_mcch_msg_type_r13_c {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "SC-MCCH-MessageType-r13");
assert_choice_type(types::c1, type_, "SC-MCCH-MessageType-r13");
return c.get<c1_c_>();
}
msg_class_ext_c_& msg_class_ext()
{
assert_choice_type("messageClassExtension", type_.to_string(), "SC-MCCH-MessageType-r13");
assert_choice_type(types::msg_class_ext, type_, "SC-MCCH-MessageType-r13");
return c.get<msg_class_ext_c_>();
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "SC-MCCH-MessageType-r13");
assert_choice_type(types::c1, type_, "SC-MCCH-MessageType-r13");
return c.get<c1_c_>();
}
const msg_class_ext_c_& msg_class_ext() const
{
assert_choice_type("messageClassExtension", type_.to_string(), "SC-MCCH-MessageType-r13");
assert_choice_type(types::msg_class_ext, type_, "SC-MCCH-MessageType-r13");
return c.get<msg_class_ext_c_>();
}
c1_c_& set_c1();
@ -1690,22 +1690,22 @@ struct cells_triggered_list_item_c_ {
// getters
uint16_t& fdd()
{
assert_choice_type("fdd", type_.to_string(), "physCellIdUTRA");
assert_choice_type(types::fdd, type_, "physCellIdUTRA");
return c.get<uint16_t>();
}
uint8_t& tdd()
{
assert_choice_type("tdd", type_.to_string(), "physCellIdUTRA");
assert_choice_type(types::tdd, type_, "physCellIdUTRA");
return c.get<uint8_t>();
}
const uint16_t& fdd() const
{
assert_choice_type("fdd", type_.to_string(), "physCellIdUTRA");
assert_choice_type(types::fdd, type_, "physCellIdUTRA");
return c.get<uint16_t>();
}
const uint8_t& tdd() const
{
assert_choice_type("tdd", type_.to_string(), "physCellIdUTRA");
assert_choice_type(types::tdd, type_, "physCellIdUTRA");
return c.get<uint8_t>();
}
uint16_t& set_fdd();
@ -1749,62 +1749,62 @@ struct cells_triggered_list_item_c_ {
// getters
uint16_t& pci_eutra()
{
assert_choice_type("physCellIdEUTRA", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::pci_eutra, type_, "CellsTriggeredList-item");
return c.get<uint16_t>();
}
pci_utra_c_& pci_utra()
{
assert_choice_type("physCellIdUTRA", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::pci_utra, type_, "CellsTriggeredList-item");
return c.get<pci_utra_c_>();
}
pci_geran_s_& pci_geran()
{
assert_choice_type("physCellIdGERAN", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::pci_geran, type_, "CellsTriggeredList-item");
return c.get<pci_geran_s_>();
}
uint16_t& pci_cdma2000()
{
assert_choice_type("physCellIdCDMA2000", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::pci_cdma2000, type_, "CellsTriggeredList-item");
return c.get<uint16_t>();
}
wlan_ids_r12_s& wlan_ids_r13()
{
assert_choice_type("wlan-Identifiers-r13", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::wlan_ids_r13, type_, "CellsTriggeredList-item");
return c.get<wlan_ids_r12_s>();
}
pci_nr_r15_s_& pci_nr_r15()
{
assert_choice_type("physCellIdNR-r15", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::pci_nr_r15, type_, "CellsTriggeredList-item");
return c.get<pci_nr_r15_s_>();
}
const uint16_t& pci_eutra() const
{
assert_choice_type("physCellIdEUTRA", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::pci_eutra, type_, "CellsTriggeredList-item");
return c.get<uint16_t>();
}
const pci_utra_c_& pci_utra() const
{
assert_choice_type("physCellIdUTRA", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::pci_utra, type_, "CellsTriggeredList-item");
return c.get<pci_utra_c_>();
}
const pci_geran_s_& pci_geran() const
{
assert_choice_type("physCellIdGERAN", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::pci_geran, type_, "CellsTriggeredList-item");
return c.get<pci_geran_s_>();
}
const uint16_t& pci_cdma2000() const
{
assert_choice_type("physCellIdCDMA2000", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::pci_cdma2000, type_, "CellsTriggeredList-item");
return c.get<uint16_t>();
}
const wlan_ids_r12_s& wlan_ids_r13() const
{
assert_choice_type("wlan-Identifiers-r13", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::wlan_ids_r13, type_, "CellsTriggeredList-item");
return c.get<wlan_ids_r12_s>();
}
const pci_nr_r15_s_& pci_nr_r15() const
{
assert_choice_type("physCellIdNR-r15", type_.to_string(), "CellsTriggeredList-item");
assert_choice_type(types::pci_nr_r15, type_, "CellsTriggeredList-item");
return c.get<pci_nr_r15_s_>();
}
uint16_t& set_pci_eutra();
@ -2142,12 +2142,12 @@ struct scg_cfg_info_r12_s {
// getters
scg_cfg_info_r12_ies_s& scg_cfg_info_r12()
{
assert_choice_type("scg-ConfigInfo-r12", type_.to_string(), "c1");
assert_choice_type(types::scg_cfg_info_r12, type_, "c1");
return c;
}
const scg_cfg_info_r12_ies_s& scg_cfg_info_r12() const
{
assert_choice_type("scg-ConfigInfo-r12", type_.to_string(), "c1");
assert_choice_type(types::scg_cfg_info_r12, type_, "c1");
return c;
}
scg_cfg_info_r12_ies_s& set_scg_cfg_info_r12();
@ -2175,12 +2175,12 @@ struct scg_cfg_info_r12_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();

356
lib/include/srsran/asn1/rrc/bcch_msg.h
View File

File diff suppressed because it is too large Load Diff

36
lib/include/srsran/asn1/rrc/common.h
Unescape Escape View File

@ -385,22 +385,22 @@ struct mbsfn_sf_cfg_s {
// getters
fixed_bitstring<6>& one_frame()
{
assert_choice_type("oneFrame", type_.to_string(), "subframeAllocation");
assert_choice_type(types::one_frame, type_, "subframeAllocation");
return c.get<fixed_bitstring<6> >();
}
fixed_bitstring<24>& four_frames()
{
assert_choice_type("fourFrames", type_.to_string(), "subframeAllocation");
assert_choice_type(types::four_frames, type_, "subframeAllocation");
return c.get<fixed_bitstring<24> >();
}
const fixed_bitstring<6>& one_frame() const
{
assert_choice_type("oneFrame", type_.to_string(), "subframeAllocation");
assert_choice_type(types::one_frame, type_, "subframeAllocation");
return c.get<fixed_bitstring<6> >();
}
const fixed_bitstring<24>& four_frames() const
{
assert_choice_type("fourFrames", type_.to_string(), "subframeAllocation");
assert_choice_type(types::four_frames, type_, "subframeAllocation");
return c.get<fixed_bitstring<24> >();
}
fixed_bitstring<6>& set_one_frame();
@ -453,22 +453,22 @@ struct mbsfn_sf_cfg_v1430_s {
// getters
fixed_bitstring<2>& one_frame_v1430()
{
assert_choice_type("oneFrame-v1430", type_.to_string(), "subframeAllocation-v1430");
assert_choice_type(types::one_frame_v1430, type_, "subframeAllocation-v1430");
return c.get<fixed_bitstring<2> >();
}
fixed_bitstring<8>& four_frames_v1430()
{
assert_choice_type("fourFrames-v1430", type_.to_string(), "subframeAllocation-v1430");
assert_choice_type(types::four_frames_v1430, type_, "subframeAllocation-v1430");
return c.get<fixed_bitstring<8> >();
}
const fixed_bitstring<2>& one_frame_v1430() const
{
assert_choice_type("oneFrame-v1430", type_.to_string(), "subframeAllocation-v1430");
assert_choice_type(types::one_frame_v1430, type_, "subframeAllocation-v1430");
return c.get<fixed_bitstring<2> >();
}
const fixed_bitstring<8>& four_frames_v1430() const
{
assert_choice_type("fourFrames-v1430", type_.to_string(), "subframeAllocation-v1430");
assert_choice_type(types::four_frames_v1430, type_, "subframeAllocation-v1430");
return c.get<fixed_bitstring<8> >();
}
fixed_bitstring<2>& set_one_frame_v1430();
@ -525,32 +525,32 @@ struct meas_sf_pattern_r10_c {
// getters
fixed_bitstring<20>& sf_cfg1_minus5_r10()
{
assert_choice_type("subframeConfig1-5-r10", type_.to_string(), "subframePatternTDD-r10");
assert_choice_type(types::sf_cfg1_minus5_r10, type_, "subframePatternTDD-r10");
return c.get<fixed_bitstring<20> >();
}
fixed_bitstring<70>& sf_cfg0_r10()
{
assert_choice_type("subframeConfig0-r10", type_.to_string(), "subframePatternTDD-r10");
assert_choice_type(types::sf_cfg0_r10, type_, "subframePatternTDD-r10");
return c.get<fixed_bitstring<70> >();
}
fixed_bitstring<60>& sf_cfg6_r10()
{
assert_choice_type("subframeConfig6-r10", type_.to_string(), "subframePatternTDD-r10");
assert_choice_type(types::sf_cfg6_r10, type_, "subframePatternTDD-r10");
return c.get<fixed_bitstring<60> >();
}
const fixed_bitstring<20>& sf_cfg1_minus5_r10() const
{
assert_choice_type("subframeConfig1-5-r10", type_.to_string(), "subframePatternTDD-r10");
assert_choice_type(types::sf_cfg1_minus5_r10, type_, "subframePatternTDD-r10");
return c.get<fixed_bitstring<20> >();
}
const fixed_bitstring<70>& sf_cfg0_r10() const
{
assert_choice_type("subframeConfig0-r10", type_.to_string(), "subframePatternTDD-r10");
assert_choice_type(types::sf_cfg0_r10, type_, "subframePatternTDD-r10");
return c.get<fixed_bitstring<70> >();
}
const fixed_bitstring<60>& sf_cfg6_r10() const
{
assert_choice_type("subframeConfig6-r10", type_.to_string(), "subframePatternTDD-r10");
assert_choice_type(types::sf_cfg6_r10, type_, "subframePatternTDD-r10");
return c.get<fixed_bitstring<60> >();
}
fixed_bitstring<20>& set_sf_cfg1_minus5_r10();
@ -585,22 +585,22 @@ struct meas_sf_pattern_r10_c {
// getters
fixed_bitstring<40>& sf_pattern_fdd_r10()
{
assert_choice_type("subframePatternFDD-r10", type_.to_string(), "MeasSubframePattern-r10");
assert_choice_type(types::sf_pattern_fdd_r10, type_, "MeasSubframePattern-r10");
return c.get<fixed_bitstring<40> >();
}
sf_pattern_tdd_r10_c_& sf_pattern_tdd_r10()
{
assert_choice_type("subframePatternTDD-r10", type_.to_string(), "MeasSubframePattern-r10");
assert_choice_type(types::sf_pattern_tdd_r10, type_, "MeasSubframePattern-r10");
return c.get<sf_pattern_tdd_r10_c_>();
}
const fixed_bitstring<40>& sf_pattern_fdd_r10() const
{
assert_choice_type("subframePatternFDD-r10", type_.to_string(), "MeasSubframePattern-r10");
assert_choice_type(types::sf_pattern_fdd_r10, type_, "MeasSubframePattern-r10");
return c.get<fixed_bitstring<40> >();
}
const sf_pattern_tdd_r10_c_& sf_pattern_tdd_r10() const
{
assert_choice_type("subframePatternTDD-r10", type_.to_string(), "MeasSubframePattern-r10");
assert_choice_type(types::sf_pattern_tdd_r10, type_, "MeasSubframePattern-r10");
return c.get<sf_pattern_tdd_r10_c_>();
}
fixed_bitstring<40>& set_sf_pattern_fdd_r10();

104
lib/include/srsran/asn1/rrc/common_ext.h
Unescape Escape View File

@ -63,12 +63,12 @@ struct sl_tx_pwr_r14_c {
// getters
int8_t& tx_pwr_r14()
{
assert_choice_type("txPower-r14", type_.to_string(), "SL-TxPower-r14");
assert_choice_type(types::tx_pwr_r14, type_, "SL-TxPower-r14");
return c;
}
const int8_t& tx_pwr_r14() const
{
assert_choice_type("txPower-r14", type_.to_string(), "SL-TxPower-r14");
assert_choice_type(types::tx_pwr_r14, type_, "SL-TxPower-r14");
return c;
}
void set_minusinfinity_r14();
@ -233,22 +233,22 @@ struct sl_offset_ind_r12_c {
// getters
uint16_t& small_r12()
{
assert_choice_type("small-r12", type_.to_string(), "SL-OffsetIndicator-r12");
assert_choice_type(types::small_r12, type_, "SL-OffsetIndicator-r12");
return c.get<uint16_t>();
}
uint16_t& large_r12()
{
assert_choice_type("large-r12", type_.to_string(), "SL-OffsetIndicator-r12");
assert_choice_type(types::large_r12, type_, "SL-OffsetIndicator-r12");
return c.get<uint16_t>();
}
const uint16_t& small_r12() const
{
assert_choice_type("small-r12", type_.to_string(), "SL-OffsetIndicator-r12");
assert_choice_type(types::small_r12, type_, "SL-OffsetIndicator-r12");
return c.get<uint16_t>();
}
const uint16_t& large_r12() const
{
assert_choice_type("large-r12", type_.to_string(), "SL-OffsetIndicator-r12");
assert_choice_type(types::large_r12, type_, "SL-OffsetIndicator-r12");
return c.get<uint16_t>();
}
uint16_t& set_small_r12();
@ -351,72 +351,72 @@ struct sf_bitmap_sl_r12_c {
// getters
fixed_bitstring<4>& bs4_r12()
{
assert_choice_type("bs4-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs4_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<4> >();
}
fixed_bitstring<8>& bs8_r12()
{
assert_choice_type("bs8-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs8_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<8> >();
}
fixed_bitstring<12>& bs12_r12()
{
assert_choice_type("bs12-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs12_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<12> >();
}
fixed_bitstring<16>& bs16_r12()
{
assert_choice_type("bs16-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs16_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<16> >();
}
fixed_bitstring<30>& bs30_r12()
{
assert_choice_type("bs30-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs30_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<30> >();
}
fixed_bitstring<40>& bs40_r12()
{
assert_choice_type("bs40-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs40_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<40> >();
}
fixed_bitstring<42>& bs42_r12()
{
assert_choice_type("bs42-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs42_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<42> >();
}
const fixed_bitstring<4>& bs4_r12() const
{
assert_choice_type("bs4-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs4_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<4> >();
}
const fixed_bitstring<8>& bs8_r12() const
{
assert_choice_type("bs8-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs8_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<8> >();
}
const fixed_bitstring<12>& bs12_r12() const
{
assert_choice_type("bs12-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs12_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<12> >();
}
const fixed_bitstring<16>& bs16_r12() const
{
assert_choice_type("bs16-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs16_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<16> >();
}
const fixed_bitstring<30>& bs30_r12() const
{
assert_choice_type("bs30-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs30_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<30> >();
}
const fixed_bitstring<40>& bs40_r12() const
{
assert_choice_type("bs40-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs40_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<40> >();
}
const fixed_bitstring<42>& bs42_r12() const
{
assert_choice_type("bs42-r12", type_.to_string(), "SubframeBitmapSL-r12");
assert_choice_type(types::bs42_r12, type_, "SubframeBitmapSL-r12");
return c.get<fixed_bitstring<42> >();
}
fixed_bitstring<4>& set_bs4_r12();
@ -458,82 +458,82 @@ struct sf_bitmap_sl_r14_c {
// getters
fixed_bitstring<10>& bs10_r14()
{
assert_choice_type("bs10-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs10_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<10> >();
}
fixed_bitstring<16>& bs16_r14()
{
assert_choice_type("bs16-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs16_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<16> >();
}
fixed_bitstring<20>& bs20_r14()
{
assert_choice_type("bs20-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs20_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<20> >();
}
fixed_bitstring<30>& bs30_r14()
{
assert_choice_type("bs30-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs30_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<30> >();
}
fixed_bitstring<40>& bs40_r14()
{
assert_choice_type("bs40-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs40_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<40> >();
}
fixed_bitstring<50>& bs50_r14()
{
assert_choice_type("bs50-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs50_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<50> >();
}
fixed_bitstring<60>& bs60_r14()
{
assert_choice_type("bs60-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs60_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<60> >();
}
fixed_bitstring<100>& bs100_r14()
{
assert_choice_type("bs100-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs100_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<100> >();
}
const fixed_bitstring<10>& bs10_r14() const
{
assert_choice_type("bs10-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs10_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<10> >();
}
const fixed_bitstring<16>& bs16_r14() const
{
assert_choice_type("bs16-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs16_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<16> >();
}
const fixed_bitstring<20>& bs20_r14() const
{
assert_choice_type("bs20-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs20_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<20> >();
}
const fixed_bitstring<30>& bs30_r14() const
{
assert_choice_type("bs30-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs30_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<30> >();
}
const fixed_bitstring<40>& bs40_r14() const
{
assert_choice_type("bs40-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs40_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<40> >();
}
const fixed_bitstring<50>& bs50_r14() const
{
assert_choice_type("bs50-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs50_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<50> >();
}
const fixed_bitstring<60>& bs60_r14() const
{
assert_choice_type("bs60-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs60_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<60> >();
}
const fixed_bitstring<100>& bs100_r14() const
{
assert_choice_type("bs100-r14", type_.to_string(), "SubframeBitmapSL-r14");
assert_choice_type(types::bs100_r14, type_, "SubframeBitmapSL-r14");
return c.get<fixed_bitstring<100> >();
}
fixed_bitstring<10>& set_bs10_r14();
@ -834,12 +834,12 @@ struct sl_disc_res_pool_r12_s {
// getters
sl_pool_sel_cfg_r12_s& rsrp_based_r12()
{
assert_choice_type("rsrpBased-r12", type_.to_string(), "poolSelection-r12");
assert_choice_type(types::rsrp_based_r12, type_, "poolSelection-r12");
return c;
}
const sl_pool_sel_cfg_r12_s& rsrp_based_r12() const
{
assert_choice_type("rsrpBased-r12", type_.to_string(), "poolSelection-r12");
assert_choice_type(types::rsrp_based_r12, type_, "poolSelection-r12");
return c;
}
sl_pool_sel_cfg_r12_s& set_rsrp_based_r12();
@ -894,12 +894,12 @@ struct sl_disc_res_pool_r12_s {
// getters
setup_e_& setup()
{
assert_choice_type("setup", type_.to_string(), "discPeriod-v1310");
assert_choice_type(types::setup, type_, "discPeriod-v1310");
return c;
}
const setup_e_& setup() const
{
assert_choice_type("setup", type_.to_string(), "discPeriod-v1310");
assert_choice_type(types::setup, type_, "discPeriod-v1310");
return c;
}
void set_release();
@ -925,12 +925,12 @@ struct sl_disc_res_pool_r12_s {
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "rxParamsAddNeighFreq-r13");
assert_choice_type(types::setup, type_, "rxParamsAddNeighFreq-r13");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "rxParamsAddNeighFreq-r13");
assert_choice_type(types::setup, type_, "rxParamsAddNeighFreq-r13");
return c;
}
void set_release();
@ -985,12 +985,12 @@ struct sl_disc_res_pool_r12_s {
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "txParamsAddNeighFreq-r13");
assert_choice_type(types::setup, type_, "txParamsAddNeighFreq-r13");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "txParamsAddNeighFreq-r13");
assert_choice_type(types::setup, type_, "txParamsAddNeighFreq-r13");
return c;
}
void set_release();
@ -1021,12 +1021,12 @@ struct sl_disc_res_pool_r12_s {
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "txParamsAddNeighFreq-v1370");
assert_choice_type(types::setup, type_, "txParamsAddNeighFreq-v1370");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "txParamsAddNeighFreq-v1370");
assert_choice_type(types::setup, type_, "txParamsAddNeighFreq-v1370");
return c;
}
void set_release();
@ -1303,12 +1303,12 @@ struct sl_disc_tx_res_inter_freq_r13_c {
// getters
sl_disc_tx_pool_list_r12_l& disc_tx_pool_common_r13()
{
assert_choice_type("discTxPoolCommon-r13", type_.to_string(), "SL-DiscTxResourcesInterFreq-r13");
assert_choice_type(types::disc_tx_pool_common_r13, type_, "SL-DiscTxResourcesInterFreq-r13");
return c;
}
const sl_disc_tx_pool_list_r12_l& disc_tx_pool_common_r13() const
{
assert_choice_type("discTxPoolCommon-r13", type_.to_string(), "SL-DiscTxResourcesInterFreq-r13");
assert_choice_type(types::disc_tx_pool_common_r13, type_, "SL-DiscTxResourcesInterFreq-r13");
return c;
}
void set_acquire_si_from_carrier_r13();
@ -1428,22 +1428,22 @@ struct sl_inter_freq_info_v2x_r14_s {
// getters
uint8_t& add_spec_emission_r14()
{
assert_choice_type("additionalSpectrumEmission-r14", type_.to_string(), "additionalSpectrumEmissionV2X-r14");
assert_choice_type(types::add_spec_emission_r14, type_, "additionalSpectrumEmissionV2X-r14");
return c.get<uint8_t>();
}
uint16_t& add_spec_emission_v1440()
{
assert_choice_type("additionalSpectrumEmission-v1440", type_.to_string(), "additionalSpectrumEmissionV2X-r14");
assert_choice_type(types::add_spec_emission_v1440, type_, "additionalSpectrumEmissionV2X-r14");
return c.get<uint16_t>();
}
const uint8_t& add_spec_emission_r14() const
{
assert_choice_type("additionalSpectrumEmission-r14", type_.to_string(), "additionalSpectrumEmissionV2X-r14");
assert_choice_type(types::add_spec_emission_r14, type_, "additionalSpectrumEmissionV2X-r14");
return c.get<uint8_t>();
}
const uint16_t& add_spec_emission_v1440() const
{
assert_choice_type("additionalSpectrumEmission-v1440", type_.to_string(), "additionalSpectrumEmissionV2X-r14");
assert_choice_type(types::add_spec_emission_v1440, type_, "additionalSpectrumEmissionV2X-r14");
return c.get<uint16_t>();
}
uint8_t& set_add_spec_emission_r14();

88
lib/include/srsran/asn1/rrc/dl_ccch_msg.h
Unescape Escape View File

@ -379,62 +379,62 @@ struct redirected_carrier_info_r15_ies_c {
// getters
uint32_t& eutra_r15()
{
assert_choice_type("eutra-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::eutra_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<uint32_t>();
}
carrier_freqs_geran_s& geran_r15()
{
assert_choice_type("geran-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::geran_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<carrier_freqs_geran_s>();
}
uint16_t& utra_fdd_r15()
{
assert_choice_type("utra-FDD-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::utra_fdd_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<uint16_t>();
}
carrier_freq_cdma2000_s& cdma2000_hrpd_r15()
{
assert_choice_type("cdma2000-HRPD-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::cdma2000_hrpd_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<carrier_freq_cdma2000_s>();
}
carrier_freq_cdma2000_s& cdma2000_minus1x_rtt_r15()
{
assert_choice_type("cdma2000-1xRTT-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::cdma2000_minus1x_rtt_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<carrier_freq_cdma2000_s>();
}
carrier_freq_list_utra_tdd_r10_l& utra_tdd_r15()
{
assert_choice_type("utra-TDD-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::utra_tdd_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<carrier_freq_list_utra_tdd_r10_l>();
}
const uint32_t& eutra_r15() const
{
assert_choice_type("eutra-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::eutra_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<uint32_t>();
}
const carrier_freqs_geran_s& geran_r15() const
{
assert_choice_type("geran-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::geran_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<carrier_freqs_geran_s>();
}
const uint16_t& utra_fdd_r15() const
{
assert_choice_type("utra-FDD-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::utra_fdd_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<uint16_t>();
}
const carrier_freq_cdma2000_s& cdma2000_hrpd_r15() const
{
assert_choice_type("cdma2000-HRPD-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::cdma2000_hrpd_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<carrier_freq_cdma2000_s>();
}
const carrier_freq_cdma2000_s& cdma2000_minus1x_rtt_r15() const
{
assert_choice_type("cdma2000-1xRTT-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::cdma2000_minus1x_rtt_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<carrier_freq_cdma2000_s>();
}
const carrier_freq_list_utra_tdd_r10_l& utra_tdd_r15() const
{
assert_choice_type("utra-TDD-r15", type_.to_string(), "RedirectedCarrierInfo-r15-IEs");
assert_choice_type(types::utra_tdd_r15, type_, "RedirectedCarrierInfo-r15-IEs");
return c.get<carrier_freq_list_utra_tdd_r10_l>();
}
uint32_t& set_eutra_r15();
@ -541,12 +541,12 @@ struct rrc_conn_reest_s {
// getters
rrc_conn_reest_r8_ies_s& rrc_conn_reest_r8()
{
assert_choice_type("rrcConnectionReestablishment-r8", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reest_r8, type_, "c1");
return c;
}
const rrc_conn_reest_r8_ies_s& rrc_conn_reest_r8() const
{
assert_choice_type("rrcConnectionReestablishment-r8", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reest_r8, type_, "c1");
return c;
}
rrc_conn_reest_r8_ies_s& set_rrc_conn_reest_r8();
@ -574,12 +574,12 @@ struct rrc_conn_reest_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();
@ -620,12 +620,12 @@ struct rrc_conn_reest_reject_s {
// getters
rrc_conn_reest_reject_r8_ies_s& rrc_conn_reest_reject_r8()
{
assert_choice_type("rrcConnectionReestablishmentReject-r8", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_reest_reject_r8, type_, "criticalExtensions");
return c;
}
const rrc_conn_reest_reject_r8_ies_s& rrc_conn_reest_reject_r8() const
{
assert_choice_type("rrcConnectionReestablishmentReject-r8", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_reest_reject_r8, type_, "criticalExtensions");
return c;
}
rrc_conn_reest_reject_r8_ies_s& set_rrc_conn_reest_reject_r8();
@ -666,12 +666,12 @@ struct rrc_conn_reject_s {
// getters
rrc_conn_reject_r8_ies_s& rrc_conn_reject_r8()
{
assert_choice_type("rrcConnectionReject-r8", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reject_r8, type_, "c1");
return c;
}
const rrc_conn_reject_r8_ies_s& rrc_conn_reject_r8() const
{
assert_choice_type("rrcConnectionReject-r8", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reject_r8, type_, "c1");
return c;
}
rrc_conn_reject_r8_ies_s& set_rrc_conn_reject_r8();
@ -695,12 +695,12 @@ struct rrc_conn_reject_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();
@ -741,12 +741,12 @@ struct rrc_conn_setup_s {
// getters
rrc_conn_setup_r8_ies_s& rrc_conn_setup_r8()
{
assert_choice_type("rrcConnectionSetup-r8", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_setup_r8, type_, "c1");
return c;
}
const rrc_conn_setup_r8_ies_s& rrc_conn_setup_r8() const
{
assert_choice_type("rrcConnectionSetup-r8", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_setup_r8, type_, "c1");
return c;
}
rrc_conn_setup_r8_ies_s& set_rrc_conn_setup_r8();
@ -774,12 +774,12 @@ struct rrc_conn_setup_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();
@ -820,12 +820,12 @@ struct rrc_early_data_complete_r15_s {
// getters
rrc_early_data_complete_r15_ies_s& rrc_early_data_complete_r15()
{
assert_choice_type("rrcEarlyDataComplete-r15", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_early_data_complete_r15, type_, "criticalExtensions");
return c;
}
const rrc_early_data_complete_r15_ies_s& rrc_early_data_complete_r15() const
{
assert_choice_type("rrcEarlyDataComplete-r15", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_early_data_complete_r15, type_, "criticalExtensions");
return c;
}
rrc_early_data_complete_r15_ies_s& set_rrc_early_data_complete_r15();
@ -868,42 +868,42 @@ struct dl_ccch_msg_type_c {
// getters
rrc_conn_reest_s& rrc_conn_reest()
{
assert_choice_type("rrcConnectionReestablishment", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reest, type_, "c1");
return c.get<rrc_conn_reest_s>();
}
rrc_conn_reest_reject_s& rrc_conn_reest_reject()
{
assert_choice_type("rrcConnectionReestablishmentReject", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reest_reject, type_, "c1");
return c.get<rrc_conn_reest_reject_s>();
}
rrc_conn_reject_s& rrc_conn_reject()
{
assert_choice_type("rrcConnectionReject", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reject, type_, "c1");
return c.get<rrc_conn_reject_s>();
}
rrc_conn_setup_s& rrc_conn_setup()
{
assert_choice_type("rrcConnectionSetup", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_setup, type_, "c1");
return c.get<rrc_conn_setup_s>();
}
const rrc_conn_reest_s& rrc_conn_reest() const
{
assert_choice_type("rrcConnectionReestablishment", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reest, type_, "c1");
return c.get<rrc_conn_reest_s>();
}
const rrc_conn_reest_reject_s& rrc_conn_reest_reject() const
{
assert_choice_type("rrcConnectionReestablishmentReject", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reest_reject, type_, "c1");
return c.get<rrc_conn_reest_reject_s>();
}
const rrc_conn_reject_s& rrc_conn_reject() const
{
assert_choice_type("rrcConnectionReject", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reject, type_, "c1");
return c.get<rrc_conn_reject_s>();
}
const rrc_conn_setup_s& rrc_conn_setup() const
{
assert_choice_type("rrcConnectionSetup", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_setup, type_, "c1");
return c.get<rrc_conn_setup_s>();
}
rrc_conn_reest_s& set_rrc_conn_reest();
@ -936,12 +936,12 @@ struct dl_ccch_msg_type_c {
// getters
rrc_early_data_complete_r15_s& rrc_early_data_complete_r15()
{
assert_choice_type("rrcEarlyDataComplete-r15", type_.to_string(), "c2");
assert_choice_type(types::rrc_early_data_complete_r15, type_, "c2");
return c;
}
const rrc_early_data_complete_r15_s& rrc_early_data_complete_r15() const
{
assert_choice_type("rrcEarlyDataComplete-r15", type_.to_string(), "c2");
assert_choice_type(types::rrc_early_data_complete_r15, type_, "c2");
return c;
}
rrc_early_data_complete_r15_s& set_rrc_early_data_complete_r15();
@ -972,12 +972,12 @@ struct dl_ccch_msg_type_c {
// getters
c2_c_& c2()
{
assert_choice_type("c2", type_.to_string(), "messageClassExtension");
assert_choice_type(types::c2, type_, "messageClassExtension");
return c;
}
const c2_c_& c2() const
{
assert_choice_type("c2", type_.to_string(), "messageClassExtension");
assert_choice_type(types::c2, type_, "messageClassExtension");
return c;
}
c2_c_& set_c2();
@ -1009,22 +1009,22 @@ struct dl_ccch_msg_type_c {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "DL-CCCH-MessageType");
assert_choice_type(types::c1, type_, "DL-CCCH-MessageType");
return c.get<c1_c_>();
}
msg_class_ext_c_& msg_class_ext()
{
assert_choice_type("messageClassExtension", type_.to_string(), "DL-CCCH-MessageType");
assert_choice_type(types::msg_class_ext, type_, "DL-CCCH-MessageType");
return c.get<msg_class_ext_c_>();
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "DL-CCCH-MessageType");
assert_choice_type(types::c1, type_, "DL-CCCH-MessageType");
return c.get<c1_c_>();
}
const msg_class_ext_c_& msg_class_ext() const
{
assert_choice_type("messageClassExtension", type_.to_string(), "DL-CCCH-MessageType");
assert_choice_type(types::msg_class_ext, type_, "DL-CCCH-MessageType");
return c.get<msg_class_ext_c_>();
}
c1_c_& set_c1();

528
lib/include/srsran/asn1/rrc/dl_dcch_msg.h
View File

File diff suppressed because it is too large Load Diff

28
lib/include/srsran/asn1/rrc/ho_cmd.h
Unescape Escape View File

@ -129,12 +129,12 @@ struct scg_cfg_r12_s {
// getters
scg_cfg_r12_ies_s& scg_cfg_r12()
{
assert_choice_type("scg-Config-r12", type_.to_string(), "c1");
assert_choice_type(types::scg_cfg_r12, type_, "c1");
return c;
}
const scg_cfg_r12_ies_s& scg_cfg_r12() const
{
assert_choice_type("scg-Config-r12", type_.to_string(), "c1");
assert_choice_type(types::scg_cfg_r12, type_, "c1");
return c;
}
scg_cfg_r12_ies_s& set_scg_cfg_r12();
@ -162,12 +162,12 @@ struct scg_cfg_r12_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();
@ -441,12 +441,12 @@ struct ho_cmd_s {
// getters
ho_cmd_r8_ies_s& ho_cmd_r8()
{
assert_choice_type("handoverCommand-r8", type_.to_string(), "c1");
assert_choice_type(types::ho_cmd_r8, type_, "c1");
return c;
}
const ho_cmd_r8_ies_s& ho_cmd_r8() const
{
assert_choice_type("handoverCommand-r8", type_.to_string(), "c1");
assert_choice_type(types::ho_cmd_r8, type_, "c1");
return c;
}
ho_cmd_r8_ies_s& set_ho_cmd_r8();
@ -474,12 +474,12 @@ struct ho_cmd_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();
@ -758,12 +758,12 @@ struct ho_prep_info_s {
// getters
ho_prep_info_r8_ies_s& ho_prep_info_r8()
{
assert_choice_type("handoverPreparationInformation-r8", type_.to_string(), "c1");
assert_choice_type(types::ho_prep_info_r8, type_, "c1");
return c;
}
const ho_prep_info_r8_ies_s& ho_prep_info_r8() const
{
assert_choice_type("handoverPreparationInformation-r8", type_.to_string(), "c1");
assert_choice_type(types::ho_prep_info_r8, type_, "c1");
return c;
}
ho_prep_info_r8_ies_s& set_ho_prep_info_r8();
@ -791,12 +791,12 @@ struct ho_prep_info_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();
@ -886,12 +886,12 @@ struct var_meas_cfg_s {
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "speedStatePars");
assert_choice_type(types::setup, type_, "speedStatePars");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "speedStatePars");
assert_choice_type(types::setup, type_, "speedStatePars");
return c;
}
void set_release();

624
lib/include/srsran/asn1/rrc/meascfg.h
View File

File diff suppressed because it is too large Load Diff

36
lib/include/srsran/asn1/rrc/paging.h
Unescape Escape View File

@ -102,42 +102,42 @@ struct paging_ue_id_c {
// getters
s_tmsi_s& s_tmsi()
{
assert_choice_type("s-TMSI", type_.to_string(), "PagingUE-Identity");
assert_choice_type(types::s_tmsi, type_, "PagingUE-Identity");
return c.get<s_tmsi_s>();
}
imsi_l& imsi()
{
assert_choice_type("imsi", type_.to_string(), "PagingUE-Identity");
assert_choice_type(types::imsi, type_, "PagingUE-Identity");
return c.get<imsi_l>();
}
fixed_bitstring<48>& ng_minus5_g_s_tmsi_r15()
{
assert_choice_type("ng-5G-S-TMSI-r15", type_.to_string(), "PagingUE-Identity");
assert_choice_type(types::ng_minus5_g_s_tmsi_r15, type_, "PagingUE-Identity");
return c.get<fixed_bitstring<48> >();
}
fixed_bitstring<40>& full_i_rnti_r15()
{
assert_choice_type("fullI-RNTI-r15", type_.to_string(), "PagingUE-Identity");
assert_choice_type(types::full_i_rnti_r15, type_, "PagingUE-Identity");
return c.get<fixed_bitstring<40> >();
}
const s_tmsi_s& s_tmsi() const
{
assert_choice_type("s-TMSI", type_.to_string(), "PagingUE-Identity");
assert_choice_type(types::s_tmsi, type_, "PagingUE-Identity");
return c.get<s_tmsi_s>();
}
const imsi_l& imsi() const
{
assert_choice_type("imsi", type_.to_string(), "PagingUE-Identity");
assert_choice_type(types::imsi, type_, "PagingUE-Identity");
return c.get<imsi_l>();
}
const fixed_bitstring<48>& ng_minus5_g_s_tmsi_r15() const
{
assert_choice_type("ng-5G-S-TMSI-r15", type_.to_string(), "PagingUE-Identity");
assert_choice_type(types::ng_minus5_g_s_tmsi_r15, type_, "PagingUE-Identity");
return c.get<fixed_bitstring<48> >();
}
const fixed_bitstring<40>& full_i_rnti_r15() const
{
assert_choice_type("fullI-RNTI-r15", type_.to_string(), "PagingUE-Identity");
assert_choice_type(types::full_i_rnti_r15, type_, "PagingUE-Identity");
return c.get<fixed_bitstring<40> >();
}
s_tmsi_s& set_s_tmsi();
@ -257,12 +257,12 @@ struct pcch_msg_type_c {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "PCCH-MessageType");
assert_choice_type(types::c1, type_, "PCCH-MessageType");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "PCCH-MessageType");
assert_choice_type(types::c1, type_, "PCCH-MessageType");
return c;
}
c1_c_& set_c1();
@ -326,12 +326,12 @@ struct ue_paging_coverage_info_s {
// getters
ue_paging_coverage_info_r13_ies_s& ue_paging_coverage_info_r13()
{
assert_choice_type("uePagingCoverageInformation-r13", type_.to_string(), "c1");
assert_choice_type(types::ue_paging_coverage_info_r13, type_, "c1");
return c;
}
const ue_paging_coverage_info_r13_ies_s& ue_paging_coverage_info_r13() const
{
assert_choice_type("uePagingCoverageInformation-r13", type_.to_string(), "c1");
assert_choice_type(types::ue_paging_coverage_info_r13, type_, "c1");
return c;
}
ue_paging_coverage_info_r13_ies_s& set_ue_paging_coverage_info_r13();
@ -359,12 +359,12 @@ struct ue_paging_coverage_info_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();
@ -442,12 +442,12 @@ struct ue_radio_paging_info_s {
// getters
ue_radio_paging_info_r12_ies_s& ue_radio_paging_info_r12()
{
assert_choice_type("ueRadioPagingInformation-r12", type_.to_string(), "c1");
assert_choice_type(types::ue_radio_paging_info_r12, type_, "c1");
return c;
}
const ue_radio_paging_info_r12_ies_s& ue_radio_paging_info_r12() const
{
assert_choice_type("ueRadioPagingInformation-r12", type_.to_string(), "c1");
assert_choice_type(types::ue_radio_paging_info_r12, type_, "c1");
return c;
}
ue_radio_paging_info_r12_ies_s& set_ue_radio_paging_info_r12();
@ -475,12 +475,12 @@ struct ue_radio_paging_info_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();

624
lib/include/srsran/asn1/rrc/phy_ded.h
View File

File diff suppressed because it is too large Load Diff

72
lib/include/srsran/asn1/rrc/rr_common.h
Unescape Escape View File

@ -81,22 +81,22 @@ struct plmn_id_info_r15_s {
// getters
plmn_id_s& plmn_id_r15()
{
assert_choice_type("plmn-Identity-r15", type_.to_string(), "plmn-Identity-5GC-r15");
assert_choice_type(types::plmn_id_r15, type_, "plmn-Identity-5GC-r15");
return c.get<plmn_id_s>();
}
uint8_t& plmn_idx_r15()
{
assert_choice_type("plmn-Index-r15", type_.to_string(), "plmn-Identity-5GC-r15");
assert_choice_type(types::plmn_idx_r15, type_, "plmn-Identity-5GC-r15");
return c.get<uint8_t>();
}
const plmn_id_s& plmn_id_r15() const
{
assert_choice_type("plmn-Identity-r15", type_.to_string(), "plmn-Identity-5GC-r15");
assert_choice_type(types::plmn_id_r15, type_, "plmn-Identity-5GC-r15");
return c.get<plmn_id_s>();
}
const uint8_t& plmn_idx_r15() const
{
assert_choice_type("plmn-Index-r15", type_.to_string(), "plmn-Identity-5GC-r15");
assert_choice_type(types::plmn_idx_r15, type_, "plmn-Identity-5GC-r15");
return c.get<uint8_t>();
}
plmn_id_s& set_plmn_id_r15();
@ -154,22 +154,22 @@ struct cell_id_minus5_gc_r15_c {
// getters
fixed_bitstring<28>& cell_id_r15()
{
assert_choice_type("cellIdentity-r15", type_.to_string(), "CellIdentity-5GC-r15");
assert_choice_type(types::cell_id_r15, type_, "CellIdentity-5GC-r15");
return c.get<fixed_bitstring<28> >();
}
uint8_t& cell_id_idx_r15()
{
assert_choice_type("cellId-Index-r15", type_.to_string(), "CellIdentity-5GC-r15");
assert_choice_type(types::cell_id_idx_r15, type_, "CellIdentity-5GC-r15");
return c.get<uint8_t>();
}
const fixed_bitstring<28>& cell_id_r15() const
{
assert_choice_type("cellIdentity-r15", type_.to_string(), "CellIdentity-5GC-r15");
assert_choice_type(types::cell_id_r15, type_, "CellIdentity-5GC-r15");
return c.get<fixed_bitstring<28> >();
}
const uint8_t& cell_id_idx_r15() const
{
assert_choice_type("cellId-Index-r15", type_.to_string(), "CellIdentity-5GC-r15");
assert_choice_type(types::cell_id_idx_r15, type_, "CellIdentity-5GC-r15");
return c.get<uint8_t>();
}
fixed_bitstring<28>& set_cell_id_r15();
@ -648,12 +648,12 @@ struct delta_flist_spucch_r15_c {
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "DeltaFList-SPUCCH-r15");
assert_choice_type(types::setup, type_, "DeltaFList-SPUCCH-r15");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "DeltaFList-SPUCCH-r15");
assert_choice_type(types::setup, type_, "DeltaFList-SPUCCH-r15");
return c;
}
void set_release();
@ -871,22 +871,22 @@ struct freq_hop_params_r13_s {
// getters
interv_fdd_r13_e_& interv_fdd_r13()
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "dummy2");
assert_choice_type(types::interv_fdd_r13, type_, "dummy2");
return c.get<interv_fdd_r13_e_>();
}
interv_tdd_r13_e_& interv_tdd_r13()
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "dummy2");
assert_choice_type(types::interv_tdd_r13, type_, "dummy2");
return c.get<interv_tdd_r13_e_>();
}
const interv_fdd_r13_e_& interv_fdd_r13() const
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "dummy2");
assert_choice_type(types::interv_fdd_r13, type_, "dummy2");
return c.get<interv_fdd_r13_e_>();
}
const interv_tdd_r13_e_& interv_tdd_r13() const
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "dummy2");
assert_choice_type(types::interv_tdd_r13, type_, "dummy2");
return c.get<interv_tdd_r13_e_>();
}
interv_fdd_r13_e_& set_interv_fdd_r13();
@ -935,22 +935,22 @@ struct freq_hop_params_r13_s {
// getters
interv_fdd_r13_e_& interv_fdd_r13()
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "dummy3");
assert_choice_type(types::interv_fdd_r13, type_, "dummy3");
return c.get<interv_fdd_r13_e_>();
}
interv_tdd_r13_e_& interv_tdd_r13()
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "dummy3");
assert_choice_type(types::interv_tdd_r13, type_, "dummy3");
return c.get<interv_tdd_r13_e_>();
}
const interv_fdd_r13_e_& interv_fdd_r13() const
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "dummy3");
assert_choice_type(types::interv_fdd_r13, type_, "dummy3");
return c.get<interv_fdd_r13_e_>();
}
const interv_tdd_r13_e_& interv_tdd_r13() const
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "dummy3");
assert_choice_type(types::interv_tdd_r13, type_, "dummy3");
return c.get<interv_tdd_r13_e_>();
}
interv_fdd_r13_e_& set_interv_fdd_r13();
@ -999,22 +999,22 @@ struct freq_hop_params_r13_s {
// getters
interv_fdd_r13_e_& interv_fdd_r13()
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "interval-ULHoppingConfigCommonModeA-r13");
assert_choice_type(types::interv_fdd_r13, type_, "interval-ULHoppingConfigCommonModeA-r13");
return c.get<interv_fdd_r13_e_>();
}
interv_tdd_r13_e_& interv_tdd_r13()
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "interval-ULHoppingConfigCommonModeA-r13");
assert_choice_type(types::interv_tdd_r13, type_, "interval-ULHoppingConfigCommonModeA-r13");
return c.get<interv_tdd_r13_e_>();
}
const interv_fdd_r13_e_& interv_fdd_r13() const
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "interval-ULHoppingConfigCommonModeA-r13");
assert_choice_type(types::interv_fdd_r13, type_, "interval-ULHoppingConfigCommonModeA-r13");
return c.get<interv_fdd_r13_e_>();
}
const interv_tdd_r13_e_& interv_tdd_r13() const
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "interval-ULHoppingConfigCommonModeA-r13");
assert_choice_type(types::interv_tdd_r13, type_, "interval-ULHoppingConfigCommonModeA-r13");
return c.get<interv_tdd_r13_e_>();
}
interv_fdd_r13_e_& set_interv_fdd_r13();
@ -1063,22 +1063,22 @@ struct freq_hop_params_r13_s {
// getters
interv_fdd_r13_e_& interv_fdd_r13()
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "interval-ULHoppingConfigCommonModeB-r13");
assert_choice_type(types::interv_fdd_r13, type_, "interval-ULHoppingConfigCommonModeB-r13");
return c.get<interv_fdd_r13_e_>();
}
interv_tdd_r13_e_& interv_tdd_r13()
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "interval-ULHoppingConfigCommonModeB-r13");
assert_choice_type(types::interv_tdd_r13, type_, "interval-ULHoppingConfigCommonModeB-r13");
return c.get<interv_tdd_r13_e_>();
}
const interv_fdd_r13_e_& interv_fdd_r13() const
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "interval-ULHoppingConfigCommonModeB-r13");
assert_choice_type(types::interv_fdd_r13, type_, "interval-ULHoppingConfigCommonModeB-r13");
return c.get<interv_fdd_r13_e_>();
}
const interv_tdd_r13_e_& interv_tdd_r13() const
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "interval-ULHoppingConfigCommonModeB-r13");
assert_choice_type(types::interv_tdd_r13, type_, "interval-ULHoppingConfigCommonModeB-r13");
return c.get<interv_tdd_r13_e_>();
}
interv_fdd_r13_e_& set_interv_fdd_r13();
@ -1311,22 +1311,22 @@ struct prach_cfg_sib_v1310_s {
// getters
fdd_r13_e_& fdd_r13()
{
assert_choice_type("fdd-r13", type_.to_string(), "mpdcch-startSF-CSS-RA-r13");
assert_choice_type(types::fdd_r13, type_, "mpdcch-startSF-CSS-RA-r13");
return c.get<fdd_r13_e_>();
}
tdd_r13_e_& tdd_r13()
{
assert_choice_type("tdd-r13", type_.to_string(), "mpdcch-startSF-CSS-RA-r13");
assert_choice_type(types::tdd_r13, type_, "mpdcch-startSF-CSS-RA-r13");
return c.get<tdd_r13_e_>();
}
const fdd_r13_e_& fdd_r13() const
{
assert_choice_type("fdd-r13", type_.to_string(), "mpdcch-startSF-CSS-RA-r13");
assert_choice_type(types::fdd_r13, type_, "mpdcch-startSF-CSS-RA-r13");
return c.get<fdd_r13_e_>();
}
const tdd_r13_e_& tdd_r13() const
{
assert_choice_type("tdd-r13", type_.to_string(), "mpdcch-startSF-CSS-RA-r13");
assert_choice_type(types::tdd_r13, type_, "mpdcch-startSF-CSS-RA-r13");
return c.get<tdd_r13_e_>();
}
fdd_r13_e_& set_fdd_r13();
@ -1766,12 +1766,12 @@ struct srs_ul_cfg_common_c {
// getters
setup_s_& setup()
{
assert_choice_type("setup", type_.to_string(), "SoundingRS-UL-ConfigCommon");
assert_choice_type(types::setup, type_, "SoundingRS-UL-ConfigCommon");
return c;
}
const setup_s_& setup() const
{
assert_choice_type("setup", type_.to_string(), "SoundingRS-UL-ConfigCommon");
assert_choice_type(types::setup, type_, "SoundingRS-UL-ConfigCommon");
return c;
}
void set_release();
@ -2411,22 +2411,22 @@ struct prach_cfg_v1310_s {
// getters
fdd_r13_e_& fdd_r13()
{
assert_choice_type("fdd-r13", type_.to_string(), "mpdcch-startSF-CSS-RA-r13");
assert_choice_type(types::fdd_r13, type_, "mpdcch-startSF-CSS-RA-r13");
return c.get<fdd_r13_e_>();
}
tdd_r13_e_& tdd_r13()
{
assert_choice_type("tdd-r13", type_.to_string(), "mpdcch-startSF-CSS-RA-r13");
assert_choice_type(types::tdd_r13, type_, "mpdcch-startSF-CSS-RA-r13");
return c.get<tdd_r13_e_>();
}
const fdd_r13_e_& fdd_r13() const
{
assert_choice_type("fdd-r13", type_.to_string(), "mpdcch-startSF-CSS-RA-r13");
assert_choice_type(types::fdd_r13, type_, "mpdcch-startSF-CSS-RA-r13");
return c.get<fdd_r13_e_>();
}
const tdd_r13_e_& tdd_r13() const
{
assert_choice_type("tdd-r13", type_.to_string(), "mpdcch-startSF-CSS-RA-r13");
assert_choice_type(types::tdd_r13, type_, "mpdcch-startSF-CSS-RA-r13");
return c.get<tdd_r13_e_>();
}
fdd_r13_e_& set_fdd_r13();

412
lib/include/srsran/asn1/rrc/rr_ded.h
View File

File diff suppressed because it is too large Load Diff

36
lib/include/srsran/asn1/rrc/security.h
Unescape Escape View File

@ -88,32 +88,32 @@ struct security_cfg_ho_v1530_s {
// getters
intra5_gc_r15_s_& intra5_gc_r15()
{
assert_choice_type("intra5GC-r15", type_.to_string(), "handoverType-v1530");
assert_choice_type(types::intra5_gc_r15, type_, "handoverType-v1530");
return c.get<intra5_gc_r15_s_>();
}
fivegc_to_epc_r15_s_& fivegc_to_epc_r15()
{
assert_choice_type("fivegc-ToEPC-r15", type_.to_string(), "handoverType-v1530");
assert_choice_type(types::fivegc_to_epc_r15, type_, "handoverType-v1530");
return c.get<fivegc_to_epc_r15_s_>();
}
epc_to5_gc_r15_s_& epc_to5_gc_r15()
{
assert_choice_type("epc-To5GC-r15", type_.to_string(), "handoverType-v1530");
assert_choice_type(types::epc_to5_gc_r15, type_, "handoverType-v1530");
return c.get<epc_to5_gc_r15_s_>();
}
const intra5_gc_r15_s_& intra5_gc_r15() const
{
assert_choice_type("intra5GC-r15", type_.to_string(), "handoverType-v1530");
assert_choice_type(types::intra5_gc_r15, type_, "handoverType-v1530");
return c.get<intra5_gc_r15_s_>();
}
const fivegc_to_epc_r15_s_& fivegc_to_epc_r15() const
{
assert_choice_type("fivegc-ToEPC-r15", type_.to_string(), "handoverType-v1530");
assert_choice_type(types::fivegc_to_epc_r15, type_, "handoverType-v1530");
return c.get<fivegc_to_epc_r15_s_>();
}
const epc_to5_gc_r15_s_& epc_to5_gc_r15() const
{
assert_choice_type("epc-To5GC-r15", type_.to_string(), "handoverType-v1530");
assert_choice_type(types::epc_to5_gc_r15, type_, "handoverType-v1530");
return c.get<epc_to5_gc_r15_s_>();
}
intra5_gc_r15_s_& set_intra5_gc_r15();
@ -171,22 +171,22 @@ struct security_cfg_ho_s {
// getters
intra_lte_s_& intra_lte()
{
assert_choice_type("intraLTE", type_.to_string(), "handoverType");
assert_choice_type(types::intra_lte, type_, "handoverType");
return c.get<intra_lte_s_>();
}
inter_rat_s_& inter_rat()
{
assert_choice_type("interRAT", type_.to_string(), "handoverType");
assert_choice_type(types::inter_rat, type_, "handoverType");
return c.get<inter_rat_s_>();
}
const intra_lte_s_& intra_lte() const
{
assert_choice_type("intraLTE", type_.to_string(), "handoverType");
assert_choice_type(types::intra_lte, type_, "handoverType");
return c.get<intra_lte_s_>();
}
const inter_rat_s_& inter_rat() const
{
assert_choice_type("interRAT", type_.to_string(), "handoverType");
assert_choice_type(types::inter_rat, type_, "handoverType");
return c.get<inter_rat_s_>();
}
intra_lte_s_& set_intra_lte();
@ -267,12 +267,12 @@ struct security_mode_cmd_s {
// getters
security_mode_cmd_r8_ies_s& security_mode_cmd_r8()
{
assert_choice_type("securityModeCommand-r8", type_.to_string(), "c1");
assert_choice_type(types::security_mode_cmd_r8, type_, "c1");
return c;
}
const security_mode_cmd_r8_ies_s& security_mode_cmd_r8() const
{
assert_choice_type("securityModeCommand-r8", type_.to_string(), "c1");
assert_choice_type(types::security_mode_cmd_r8, type_, "c1");
return c;
}
security_mode_cmd_r8_ies_s& set_security_mode_cmd_r8();
@ -296,12 +296,12 @@ struct security_mode_cmd_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();
@ -388,12 +388,12 @@ struct security_mode_complete_s {
// getters
security_mode_complete_r8_ies_s& security_mode_complete_r8()
{
assert_choice_type("securityModeComplete-r8", type_.to_string(), "criticalExtensions");
assert_choice_type(types::security_mode_complete_r8, type_, "criticalExtensions");
return c;
}
const security_mode_complete_r8_ies_s& security_mode_complete_r8() const
{
assert_choice_type("securityModeComplete-r8", type_.to_string(), "criticalExtensions");
assert_choice_type(types::security_mode_complete_r8, type_, "criticalExtensions");
return c;
}
security_mode_complete_r8_ies_s& set_security_mode_complete_r8();
@ -434,12 +434,12 @@ struct security_mode_fail_s {
// getters
security_mode_fail_r8_ies_s& security_mode_fail_r8()
{
assert_choice_type("securityModeFailure-r8", type_.to_string(), "criticalExtensions");
assert_choice_type(types::security_mode_fail_r8, type_, "criticalExtensions");
return c;
}
const security_mode_fail_r8_ies_s& security_mode_fail_r8() const
{
assert_choice_type("securityModeFailure-r8", type_.to_string(), "criticalExtensions");
assert_choice_type(types::security_mode_fail_r8, type_, "criticalExtensions");
return c;
}
security_mode_fail_r8_ies_s& set_security_mode_fail_r8();

28
lib/include/srsran/asn1/rrc/si.h
Unescape Escape View File

@ -255,12 +255,12 @@ struct sib_type1_v1530_ies_s {
// getters
crs_intf_mitig_num_prbs_e_& crs_intf_mitig_num_prbs()
{
assert_choice_type("crs-IntfMitigNumPRBs", type_.to_string(), "crs-IntfMitigConfig-r15");
assert_choice_type(types::crs_intf_mitig_num_prbs, type_, "crs-IntfMitigConfig-r15");
return c;
}
const crs_intf_mitig_num_prbs_e_& crs_intf_mitig_num_prbs() const
{
assert_choice_type("crs-IntfMitigNumPRBs", type_.to_string(), "crs-IntfMitigConfig-r15");
assert_choice_type(types::crs_intf_mitig_num_prbs, type_, "crs-IntfMitigConfig-r15");
return c;
}
void set_crs_intf_mitig_enabled();
@ -537,22 +537,22 @@ struct sib_type1_v1320_ies_s {
// getters
interv_fdd_r13_e_& interv_fdd_r13()
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "interval-DLHoppingConfigCommonModeA-r13");
assert_choice_type(types::interv_fdd_r13, type_, "interval-DLHoppingConfigCommonModeA-r13");
return c.get<interv_fdd_r13_e_>();
}
interv_tdd_r13_e_& interv_tdd_r13()
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "interval-DLHoppingConfigCommonModeA-r13");
assert_choice_type(types::interv_tdd_r13, type_, "interval-DLHoppingConfigCommonModeA-r13");
return c.get<interv_tdd_r13_e_>();
}
const interv_fdd_r13_e_& interv_fdd_r13() const
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "interval-DLHoppingConfigCommonModeA-r13");
assert_choice_type(types::interv_fdd_r13, type_, "interval-DLHoppingConfigCommonModeA-r13");
return c.get<interv_fdd_r13_e_>();
}
const interv_tdd_r13_e_& interv_tdd_r13() const
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "interval-DLHoppingConfigCommonModeA-r13");
assert_choice_type(types::interv_tdd_r13, type_, "interval-DLHoppingConfigCommonModeA-r13");
return c.get<interv_tdd_r13_e_>();
}
interv_fdd_r13_e_& set_interv_fdd_r13();
@ -601,22 +601,22 @@ struct sib_type1_v1320_ies_s {
// getters
interv_fdd_r13_e_& interv_fdd_r13()
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "interval-DLHoppingConfigCommonModeB-r13");
assert_choice_type(types::interv_fdd_r13, type_, "interval-DLHoppingConfigCommonModeB-r13");
return c.get<interv_fdd_r13_e_>();
}
interv_tdd_r13_e_& interv_tdd_r13()
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "interval-DLHoppingConfigCommonModeB-r13");
assert_choice_type(types::interv_tdd_r13, type_, "interval-DLHoppingConfigCommonModeB-r13");
return c.get<interv_tdd_r13_e_>();
}
const interv_fdd_r13_e_& interv_fdd_r13() const
{
assert_choice_type("interval-FDD-r13", type_.to_string(), "interval-DLHoppingConfigCommonModeB-r13");
assert_choice_type(types::interv_fdd_r13, type_, "interval-DLHoppingConfigCommonModeB-r13");
return c.get<interv_fdd_r13_e_>();
}
const interv_tdd_r13_e_& interv_tdd_r13() const
{
assert_choice_type("interval-TDD-r13", type_.to_string(), "interval-DLHoppingConfigCommonModeB-r13");
assert_choice_type(types::interv_tdd_r13, type_, "interval-DLHoppingConfigCommonModeB-r13");
return c.get<interv_tdd_r13_e_>();
}
interv_fdd_r13_e_& set_interv_fdd_r13();
@ -738,22 +738,22 @@ struct sib_type1_v1310_ies_s {
// getters
fixed_bitstring<10>& sf_pattern10_r13()
{
assert_choice_type("subframePattern10-r13", type_.to_string(), "fdd-DownlinkOrTddSubframeBitmapBR-r13");
assert_choice_type(types::sf_pattern10_r13, type_, "fdd-DownlinkOrTddSubframeBitmapBR-r13");
return c.get<fixed_bitstring<10> >();
}
fixed_bitstring<40>& sf_pattern40_r13()
{
assert_choice_type("subframePattern40-r13", type_.to_string(), "fdd-DownlinkOrTddSubframeBitmapBR-r13");
assert_choice_type(types::sf_pattern40_r13, type_, "fdd-DownlinkOrTddSubframeBitmapBR-r13");
return c.get<fixed_bitstring<40> >();
}
const fixed_bitstring<10>& sf_pattern10_r13() const
{
assert_choice_type("subframePattern10-r13", type_.to_string(), "fdd-DownlinkOrTddSubframeBitmapBR-r13");
assert_choice_type(types::sf_pattern10_r13, type_, "fdd-DownlinkOrTddSubframeBitmapBR-r13");
return c.get<fixed_bitstring<10> >();
}
const fixed_bitstring<40>& sf_pattern40_r13() const
{
assert_choice_type("subframePattern40-r13", type_.to_string(), "fdd-DownlinkOrTddSubframeBitmapBR-r13");
assert_choice_type(types::sf_pattern40_r13, type_, "fdd-DownlinkOrTddSubframeBitmapBR-r13");
return c.get<fixed_bitstring<40> >();
}
fixed_bitstring<10>& set_sf_pattern10_r13();

52
lib/include/srsran/asn1/rrc/uecap.h
Unescape Escape View File

@ -212,12 +212,12 @@ struct ue_cap_enquiry_s {
// getters
ue_cap_enquiry_r8_ies_s& ue_cap_enquiry_r8()
{
assert_choice_type("ueCapabilityEnquiry-r8", type_.to_string(), "c1");
assert_choice_type(types::ue_cap_enquiry_r8, type_, "c1");
return c;
}
const ue_cap_enquiry_r8_ies_s& ue_cap_enquiry_r8() const
{
assert_choice_type("ueCapabilityEnquiry-r8", type_.to_string(), "c1");
assert_choice_type(types::ue_cap_enquiry_r8, type_, "c1");
return c;
}
ue_cap_enquiry_r8_ies_s& set_ue_cap_enquiry_r8();
@ -241,12 +241,12 @@ struct ue_cap_enquiry_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();
@ -381,12 +381,12 @@ struct ue_cap_info_s {
// getters
ue_cap_info_r8_ies_s& ue_cap_info_r8()
{
assert_choice_type("ueCapabilityInformation-r8", type_.to_string(), "c1");
assert_choice_type(types::ue_cap_info_r8, type_, "c1");
return c;
}
const ue_cap_info_r8_ies_s& ue_cap_info_r8() const
{
assert_choice_type("ueCapabilityInformation-r8", type_.to_string(), "c1");
assert_choice_type(types::ue_cap_info_r8, type_, "c1");
return c;
}
ue_cap_info_r8_ies_s& set_ue_cap_info_r8();
@ -414,12 +414,12 @@ struct ue_cap_info_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();
@ -694,32 +694,32 @@ struct band_combination_params_r13_s {
// getters
fixed_bitstring<3>& three_entries_r13()
{
assert_choice_type("threeEntries-r13", type_.to_string(), "supportedCellGrouping-r13");
assert_choice_type(types::three_entries_r13, type_, "supportedCellGrouping-r13");
return c.get<fixed_bitstring<3> >();
}
fixed_bitstring<7>& four_entries_r13()
{
assert_choice_type("fourEntries-r13", type_.to_string(), "supportedCellGrouping-r13");
assert_choice_type(types::four_entries_r13, type_, "supportedCellGrouping-r13");
return c.get<fixed_bitstring<7> >();
}
fixed_bitstring<15>& five_entries_r13()
{
assert_choice_type("fiveEntries-r13", type_.to_string(), "supportedCellGrouping-r13");
assert_choice_type(types::five_entries_r13, type_, "supportedCellGrouping-r13");
return c.get<fixed_bitstring<15> >();
}
const fixed_bitstring<3>& three_entries_r13() const
{
assert_choice_type("threeEntries-r13", type_.to_string(), "supportedCellGrouping-r13");
assert_choice_type(types::three_entries_r13, type_, "supportedCellGrouping-r13");
return c.get<fixed_bitstring<3> >();
}
const fixed_bitstring<7>& four_entries_r13() const
{
assert_choice_type("fourEntries-r13", type_.to_string(), "supportedCellGrouping-r13");
assert_choice_type(types::four_entries_r13, type_, "supportedCellGrouping-r13");
return c.get<fixed_bitstring<7> >();
}
const fixed_bitstring<15>& five_entries_r13() const
{
assert_choice_type("fiveEntries-r13", type_.to_string(), "supportedCellGrouping-r13");
assert_choice_type(types::five_entries_r13, type_, "supportedCellGrouping-r13");
return c.get<fixed_bitstring<15> >();
}
fixed_bitstring<3>& set_three_entries_r13();
@ -877,32 +877,32 @@ struct band_combination_params_v1250_s {
// getters
fixed_bitstring<3>& three_entries_r12()
{
assert_choice_type("threeEntries-r12", type_.to_string(), "supportedCellGrouping-r12");
assert_choice_type(types::three_entries_r12, type_, "supportedCellGrouping-r12");
return c.get<fixed_bitstring<3> >();
}
fixed_bitstring<7>& four_entries_r12()
{
assert_choice_type("fourEntries-r12", type_.to_string(), "supportedCellGrouping-r12");
assert_choice_type(types::four_entries_r12, type_, "supportedCellGrouping-r12");
return c.get<fixed_bitstring<7> >();
}
fixed_bitstring<15>& five_entries_r12()
{
assert_choice_type("fiveEntries-r12", type_.to_string(), "supportedCellGrouping-r12");
assert_choice_type(types::five_entries_r12, type_, "supportedCellGrouping-r12");
return c.get<fixed_bitstring<15> >();
}
const fixed_bitstring<3>& three_entries_r12() const
{
assert_choice_type("threeEntries-r12", type_.to_string(), "supportedCellGrouping-r12");
assert_choice_type(types::three_entries_r12, type_, "supportedCellGrouping-r12");
return c.get<fixed_bitstring<3> >();
}
const fixed_bitstring<7>& four_entries_r12() const
{
assert_choice_type("fourEntries-r12", type_.to_string(), "supportedCellGrouping-r12");
assert_choice_type(types::four_entries_r12, type_, "supportedCellGrouping-r12");
return c.get<fixed_bitstring<7> >();
}
const fixed_bitstring<15>& five_entries_r12() const
{
assert_choice_type("fiveEntries-r12", type_.to_string(), "supportedCellGrouping-r12");
assert_choice_type(types::five_entries_r12, type_, "supportedCellGrouping-r12");
return c.get<fixed_bitstring<15> >();
}
fixed_bitstring<3>& set_three_entries_r12();
@ -5193,12 +5193,12 @@ struct mbms_params_v1470_s {
// getters
uint8_t& explicit_value()
{
assert_choice_type("explicitValue", type_.to_string(), "mbms-MaxBW-r14");
assert_choice_type(types::explicit_value, type_, "mbms-MaxBW-r14");
return c;
}
const uint8_t& explicit_value() const
{
assert_choice_type("explicitValue", type_.to_string(), "mbms-MaxBW-r14");
assert_choice_type(types::explicit_value, type_, "mbms-MaxBW-r14");
return c;
}
void set_implicit_value();
@ -5688,12 +5688,12 @@ struct ue_radio_access_cap_info_s {
// getters
ue_radio_access_cap_info_r8_ies_s& ue_radio_access_cap_info_r8()
{
assert_choice_type("ueRadioAccessCapabilityInformation-r8", type_.to_string(), "c1");
assert_choice_type(types::ue_radio_access_cap_info_r8, type_, "c1");
return c;
}
const ue_radio_access_cap_info_r8_ies_s& ue_radio_access_cap_info_r8() const
{
assert_choice_type("ueRadioAccessCapabilityInformation-r8", type_.to_string(), "c1");
assert_choice_type(types::ue_radio_access_cap_info_r8, type_, "c1");
return c;
}
ue_radio_access_cap_info_r8_ies_s& set_ue_radio_access_cap_info_r8();
@ -5721,12 +5721,12 @@ struct ue_radio_access_cap_info_s {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "criticalExtensions");
assert_choice_type(types::c1, type_, "criticalExtensions");
return c;
}
c1_c_& set_c1();

88
lib/include/srsran/asn1/rrc/ul_ccch_msg.h
Unescape Escape View File

@ -86,22 +86,22 @@ struct init_ue_id_c {
// getters
s_tmsi_s& s_tmsi()
{
assert_choice_type("s-TMSI", type_.to_string(), "InitialUE-Identity");
assert_choice_type(types::s_tmsi, type_, "InitialUE-Identity");
return c.get<s_tmsi_s>();
}
fixed_bitstring<40>& random_value()
{
assert_choice_type("randomValue", type_.to_string(), "InitialUE-Identity");
assert_choice_type(types::random_value, type_, "InitialUE-Identity");
return c.get<fixed_bitstring<40> >();
}
const s_tmsi_s& s_tmsi() const
{
assert_choice_type("s-TMSI", type_.to_string(), "InitialUE-Identity");
assert_choice_type(types::s_tmsi, type_, "InitialUE-Identity");
return c.get<s_tmsi_s>();
}
const fixed_bitstring<40>& random_value() const
{
assert_choice_type("randomValue", type_.to_string(), "InitialUE-Identity");
assert_choice_type(types::random_value, type_, "InitialUE-Identity");
return c.get<fixed_bitstring<40> >();
}
s_tmsi_s& set_s_tmsi();
@ -138,22 +138,22 @@ struct init_ue_id_minus5_gc_c {
// getters
fixed_bitstring<40>& ng_minus5_g_s_tmsi_part1()
{
assert_choice_type("ng-5G-S-TMSI-Part1", type_.to_string(), "InitialUE-Identity-5GC");
assert_choice_type(types::ng_minus5_g_s_tmsi_part1, type_, "InitialUE-Identity-5GC");
return c.get<fixed_bitstring<40> >();
}
fixed_bitstring<40>& random_value()
{
assert_choice_type("randomValue", type_.to_string(), "InitialUE-Identity-5GC");
assert_choice_type(types::random_value, type_, "InitialUE-Identity-5GC");
return c.get<fixed_bitstring<40> >();
}
const fixed_bitstring<40>& ng_minus5_g_s_tmsi_part1() const
{
assert_choice_type("ng-5G-S-TMSI-Part1", type_.to_string(), "InitialUE-Identity-5GC");
assert_choice_type(types::ng_minus5_g_s_tmsi_part1, type_, "InitialUE-Identity-5GC");
return c.get<fixed_bitstring<40> >();
}
const fixed_bitstring<40>& random_value() const
{
assert_choice_type("randomValue", type_.to_string(), "InitialUE-Identity-5GC");
assert_choice_type(types::random_value, type_, "InitialUE-Identity-5GC");
return c.get<fixed_bitstring<40> >();
}
fixed_bitstring<40>& set_ng_minus5_g_s_tmsi_part1();
@ -293,22 +293,22 @@ struct rrc_conn_resume_request_minus5_gc_r15_ies_s {
// getters
fixed_bitstring<40>& full_i_rnti_r15()
{
assert_choice_type("fullI-RNTI-r15", type_.to_string(), "resumeIdentity-r15");
assert_choice_type(types::full_i_rnti_r15, type_, "resumeIdentity-r15");
return c.get<fixed_bitstring<40> >();
}
fixed_bitstring<24>& short_i_rnti_r15()
{
assert_choice_type("shortI-RNTI-r15", type_.to_string(), "resumeIdentity-r15");
assert_choice_type(types::short_i_rnti_r15, type_, "resumeIdentity-r15");
return c.get<fixed_bitstring<24> >();
}
const fixed_bitstring<40>& full_i_rnti_r15() const
{
assert_choice_type("fullI-RNTI-r15", type_.to_string(), "resumeIdentity-r15");
assert_choice_type(types::full_i_rnti_r15, type_, "resumeIdentity-r15");
return c.get<fixed_bitstring<40> >();
}
const fixed_bitstring<24>& short_i_rnti_r15() const
{
assert_choice_type("shortI-RNTI-r15", type_.to_string(), "resumeIdentity-r15");
assert_choice_type(types::short_i_rnti_r15, type_, "resumeIdentity-r15");
return c.get<fixed_bitstring<24> >();
}
fixed_bitstring<40>& set_full_i_rnti_r15();
@ -356,22 +356,22 @@ struct rrc_conn_resume_request_r13_ies_s {
// getters
fixed_bitstring<40>& resume_id_r13()
{
assert_choice_type("resumeID-r13", type_.to_string(), "resumeIdentity-r13");
assert_choice_type(types::resume_id_r13, type_, "resumeIdentity-r13");
return c.get<fixed_bitstring<40> >();
}
fixed_bitstring<24>& truncated_resume_id_r13()
{
assert_choice_type("truncatedResumeID-r13", type_.to_string(), "resumeIdentity-r13");
assert_choice_type(types::truncated_resume_id_r13, type_, "resumeIdentity-r13");
return c.get<fixed_bitstring<24> >();
}
const fixed_bitstring<40>& resume_id_r13() const
{
assert_choice_type("resumeID-r13", type_.to_string(), "resumeIdentity-r13");
assert_choice_type(types::resume_id_r13, type_, "resumeIdentity-r13");
return c.get<fixed_bitstring<40> >();
}
const fixed_bitstring<24>& truncated_resume_id_r13() const
{
assert_choice_type("truncatedResumeID-r13", type_.to_string(), "resumeIdentity-r13");
assert_choice_type(types::truncated_resume_id_r13, type_, "resumeIdentity-r13");
return c.get<fixed_bitstring<24> >();
}
fixed_bitstring<40>& set_resume_id_r13();
@ -438,12 +438,12 @@ struct rrc_conn_reest_request_s {
// getters
rrc_conn_reest_request_r8_ies_s& rrc_conn_reest_request_r8()
{
assert_choice_type("rrcConnectionReestablishmentRequest-r8", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_reest_request_r8, type_, "criticalExtensions");
return c;
}
const rrc_conn_reest_request_r8_ies_s& rrc_conn_reest_request_r8() const
{
assert_choice_type("rrcConnectionReestablishmentRequest-r8", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_reest_request_r8, type_, "criticalExtensions");
return c;
}
rrc_conn_reest_request_r8_ies_s& set_rrc_conn_reest_request_r8();
@ -486,22 +486,22 @@ struct rrc_conn_request_s {
// getters
rrc_conn_request_r8_ies_s& rrc_conn_request_r8()
{
assert_choice_type("rrcConnectionRequest-r8", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_request_r8, type_, "criticalExtensions");
return c.get<rrc_conn_request_r8_ies_s>();
}
rrc_conn_request_minus5_gc_r15_ies_s& rrc_conn_request_r15()
{
assert_choice_type("rrcConnectionRequest-r15", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_request_r15, type_, "criticalExtensions");
return c.get<rrc_conn_request_minus5_gc_r15_ies_s>();
}
const rrc_conn_request_r8_ies_s& rrc_conn_request_r8() const
{
assert_choice_type("rrcConnectionRequest-r8", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_request_r8, type_, "criticalExtensions");
return c.get<rrc_conn_request_r8_ies_s>();
}
const rrc_conn_request_minus5_gc_r15_ies_s& rrc_conn_request_r15() const
{
assert_choice_type("rrcConnectionRequest-r15", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_request_r15, type_, "criticalExtensions");
return c.get<rrc_conn_request_minus5_gc_r15_ies_s>();
}
rrc_conn_request_r8_ies_s& set_rrc_conn_request_r8();
@ -546,22 +546,22 @@ struct rrc_conn_resume_request_r13_s {
// getters
rrc_conn_resume_request_r13_ies_s& rrc_conn_resume_request_r13()
{
assert_choice_type("rrcConnectionResumeRequest-r13", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_resume_request_r13, type_, "criticalExtensions");
return c.get<rrc_conn_resume_request_r13_ies_s>();
}
rrc_conn_resume_request_minus5_gc_r15_ies_s& rrc_conn_resume_request_r15()
{
assert_choice_type("rrcConnectionResumeRequest-r15", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_resume_request_r15, type_, "criticalExtensions");
return c.get<rrc_conn_resume_request_minus5_gc_r15_ies_s>();
}
const rrc_conn_resume_request_r13_ies_s& rrc_conn_resume_request_r13() const
{
assert_choice_type("rrcConnectionResumeRequest-r13", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_resume_request_r13, type_, "criticalExtensions");
return c.get<rrc_conn_resume_request_r13_ies_s>();
}
const rrc_conn_resume_request_minus5_gc_r15_ies_s& rrc_conn_resume_request_r15() const
{
assert_choice_type("rrcConnectionResumeRequest-r15", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_conn_resume_request_r15, type_, "criticalExtensions");
return c.get<rrc_conn_resume_request_minus5_gc_r15_ies_s>();
}
rrc_conn_resume_request_r13_ies_s& set_rrc_conn_resume_request_r13();
@ -603,12 +603,12 @@ struct rrc_early_data_request_r15_s {
// getters
rrc_early_data_request_r15_ies_s& rrc_early_data_request_r15()
{
assert_choice_type("rrcEarlyDataRequest-r15", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_early_data_request_r15, type_, "criticalExtensions");
return c;
}
const rrc_early_data_request_r15_ies_s& rrc_early_data_request_r15() const
{
assert_choice_type("rrcEarlyDataRequest-r15", type_.to_string(), "criticalExtensions");
assert_choice_type(types::rrc_early_data_request_r15, type_, "criticalExtensions");
return c;
}
rrc_early_data_request_r15_ies_s& set_rrc_early_data_request_r15();
@ -651,22 +651,22 @@ struct ul_ccch_msg_type_c {
// getters
rrc_conn_reest_request_s& rrc_conn_reest_request()
{
assert_choice_type("rrcConnectionReestablishmentRequest", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reest_request, type_, "c1");
return c.get<rrc_conn_reest_request_s>();
}
rrc_conn_request_s& rrc_conn_request()
{
assert_choice_type("rrcConnectionRequest", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_request, type_, "c1");
return c.get<rrc_conn_request_s>();
}
const rrc_conn_reest_request_s& rrc_conn_reest_request() const
{
assert_choice_type("rrcConnectionReestablishmentRequest", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_reest_request, type_, "c1");
return c.get<rrc_conn_reest_request_s>();
}
const rrc_conn_request_s& rrc_conn_request() const
{
assert_choice_type("rrcConnectionRequest", type_.to_string(), "c1");
assert_choice_type(types::rrc_conn_request, type_, "c1");
return c.get<rrc_conn_request_s>();
}
rrc_conn_reest_request_s& set_rrc_conn_reest_request();
@ -718,12 +718,12 @@ struct ul_ccch_msg_type_c {
// getters
rrc_early_data_request_r15_s& rrc_early_data_request_r15()
{
assert_choice_type("rrcEarlyDataRequest-r15", type_.to_string(), "c3");
assert_choice_type(types::rrc_early_data_request_r15, type_, "c3");
return c;
}
const rrc_early_data_request_r15_s& rrc_early_data_request_r15() const
{
assert_choice_type("rrcEarlyDataRequest-r15", type_.to_string(), "c3");
assert_choice_type(types::rrc_early_data_request_r15, type_, "c3");
return c;
}
rrc_early_data_request_r15_s& set_rrc_early_data_request_r15();
@ -754,12 +754,12 @@ struct ul_ccch_msg_type_c {
// getters
c3_c_& c3()
{
assert_choice_type("c3", type_.to_string(), "messageClassExtensionFuture-r13");
assert_choice_type(types::c3, type_, "messageClassExtensionFuture-r13");
return c;
}
const c3_c_& c3() const
{
assert_choice_type("c3", type_.to_string(), "messageClassExtensionFuture-r13");
assert_choice_type(types::c3, type_, "messageClassExtensionFuture-r13");
return c;
}
c3_c_& set_c3();
@ -791,22 +791,22 @@ struct ul_ccch_msg_type_c {
// getters
c2_c_& c2()
{
assert_choice_type("c2", type_.to_string(), "messageClassExtension");
assert_choice_type(types::c2, type_, "messageClassExtension");
return c.get<c2_c_>();
}
msg_class_ext_future_r13_c_& msg_class_ext_future_r13()
{
assert_choice_type("messageClassExtensionFuture-r13", type_.to_string(), "messageClassExtension");
assert_choice_type(types::msg_class_ext_future_r13, type_, "messageClassExtension");
return c.get<msg_class_ext_future_r13_c_>();
}
const c2_c_& c2() const
{
assert_choice_type("c2", type_.to_string(), "messageClassExtension");
assert_choice_type(types::c2, type_, "messageClassExtension");
return c.get<c2_c_>();
}
const msg_class_ext_future_r13_c_& msg_class_ext_future_r13() const
{
assert_choice_type("messageClassExtensionFuture-r13", type_.to_string(), "messageClassExtension");
assert_choice_type(types::msg_class_ext_future_r13, type_, "messageClassExtension");
return c.get<msg_class_ext_future_r13_c_>();
}
c2_c_& set_c2();
@ -840,22 +840,22 @@ struct ul_ccch_msg_type_c {
// getters
c1_c_& c1()
{
assert_choice_type("c1", type_.to_string(), "UL-CCCH-MessageType");
assert_choice_type(types::c1, type_, "UL-CCCH-MessageType");
return c.get<c1_c_>();
}
msg_class_ext_c_& msg_class_ext()
{
assert_choice_type("messageClassExtension", type_.to_string(), "UL-CCCH-MessageType");
assert_choice_type(types::msg_class_ext, type_, "UL-CCCH-MessageType");
return c.get<msg_class_ext_c_>();
}
const c1_c_& c1() const
{
assert_choice_type("c1", type_.to_string(), "UL-CCCH-MessageType");
assert_choice_type(types::c1, type_, "UL-CCCH-MessageType");
return c.get<c1_c_>();
}
const msg_class_ext_c_& msg_class_ext() const
{
assert_choice_type("messageClassExtension", type_.to_string(), "UL-CCCH-MessageType");
assert_choice_type(types::msg_class_ext, type_, "UL-CCCH-MessageType");
return c.get<msg_class_ext_c_>();
}
c1_c_& set_c1();

476
lib/include/srsran/asn1/rrc/ul_dcch_msg.h
View File

File diff suppressed because it is too large Load Diff

612
lib/include/srsran/asn1/rrc_nbiot.h
View File

File diff suppressed because it is too large Load Diff

1976
lib/include/srsran/asn1/rrc_nr.h
View File

File diff suppressed because it is too large Load Diff

356
lib/include/srsran/asn1/s1ap.h
View File

File diff suppressed because it is too large Load Diff

9
lib/src/asn1/asn1_utils.cc
Unescape Escape View File

@ -32,18 +32,11 @@ void invalid_enum_number(int value, const char* name)
void assert_choice_type(uint32_t val, uint32_t choice_id)
{
if (val != choice_id) {
if (srsran_unlikely(val != choice_id)) {
log_invalid_access_choice_id(val, choice_id);
}
}
void assert_choice_type(const char* access_type, const char* current_type, const char* choice_type)
{
if (access_type != current_type) {
log_error("Invalid field access for choice type \"%s\" (\"%s\"!=\"%s\")", choice_type, access_type, current_type);
}
}
/************************
error handling
************************/

1844
lib/src/asn1/ngap.cc
View File

File diff suppressed because it is too large Load Diff

2652
lib/src/asn1/s1ap.cc
View File

File diff suppressed because it is too large Load Diff
Write Preview
Loading…
Cancel
Save