1 /*****************************************************************************
2 # Copyright 2019 AT&T Intellectual Property *
4 # Licensed under the Apache License, Version 2.0 (the "License"); *
5 # you may not use this file except in compliance with the License. *
6 # You may obtain a copy of the License at *
8 # http://www.apache.org/licenses/LICENSE-2.0 *
10 # Unless required by applicable law or agreed to in writing, software *
11 # distributed under the License is distributed on an "AS IS" BASIS, *
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
13 # See the License for the specific language governing permissions and *
14 # limitations under the License. *
16 ******************************************************************************/
20 #include "asn/asn.hpp"
21 static_assert(ASN_API_VERSION_MAJOR == 5, "re-generate the ASN parser's code using 'make regen-asn' (do not use -j option)");
23 #include "X2AP-Constants.hpp"
24 #include "X2AP-CommonDataTypes.hpp"
25 #include "X2AP-Containers.hpp"
28 DL-ABS-status::= INTEGER (0..100)
31 struct DL_ABS_status : asn::integer<>
33 using constraint_t = asn::constraints<false,asn::span<0, 100>>;
34 static constexpr const char* name() {return "DL-ABS-status";}
35 using parent_t = asn::integer<>;
40 UsableABSInformationFDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
45 struct UsableABSInformationFDD_ExtIEs
47 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
49 size_t get_index() const {return type;}
50 bool is_unknown() const { return type == 1; }
51 void clear() {type = 0;}
52 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
53 template<typename V> bool decode(V& v)
56 if(!v(ref_nested())) return false;
57 { type = 1; return true;}
61 template<typename V> bool encode(V& v) const
63 return v(ref_nested());
67 template<typename V> bool decode(size_t index, V& v)
72 case 1: type = 1; return v(ref_nested());
78 template<typename V> bool encode(size_t index, V& v) const
80 if(index != type) {return false;} return v(ref_nested());
87 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
89 size_t get_index() const {return type;}
90 bool is_unknown() const { return type == 1; }
91 void clear() {type = 0;}
92 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
93 template<typename V> bool decode(V& v)
96 if(!v(ref_nested())) return false;
97 { type = 1; return true;}
101 template<typename V> bool encode(V& v) const
103 return v(ref_nested());
107 template<typename V> bool decode(size_t index, V& v)
112 case 1: type = 1; return v(ref_nested());
113 ref_nested().clear();
118 template<typename V> bool encode(size_t index, V& v) const
120 if(index != type) {return false;} return v(ref_nested());
127 struct Extension_t : asn::typefield<true>
129 ~Extension_t() {clear();}
130 size_t get_index() const {return type;}
131 bool is_unknown() const { return type == 1; }
134 type = 0; ref_nested().clear();
136 template<typename V> static inline void enumerate(V& v)
141 template<typename V> bool decode(size_t index, V& v)
146 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
151 template<typename V> bool encode(size_t index, V& v) const
153 if(index != type) return false;
161 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
163 size_t get_index() const {return type;}
164 bool is_unknown() const { return type == 1; }
165 void clear() {type = 0;}
166 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
167 template<typename V> bool decode(V& v)
170 if(!v(ref_nested())) return false;
171 { type = 1; return true;}
175 template<typename V> bool encode(V& v) const
177 return v(ref_nested());
181 template<typename V> bool decode(size_t index, V& v)
186 case 1: type = 1; return v(ref_nested());
187 ref_nested().clear();
192 template<typename V> bool encode(size_t index, V& v) const
194 if(index != type) {return false;} return v(ref_nested());
204 UsableABSInformationFDD ::= SEQUENCE {
205 usable-abs-pattern-info BIT STRING (SIZE(40)),
206 iE-Extensions ProtocolExtensionContainer { {UsableABSInformationFDD-ExtIEs} } OPTIONAL,
211 struct UsableABSInformationFDD : asn::sequence<2, 0, true, 1>
213 static constexpr const char* name() {return "UsableABSInformationFDD";}
214 using parent_t = asn::sequence<2, 0, true, 1>;
215 struct usable_abs_pattern_info_t : asn::bstring<>
217 using constraint_t = asn::constraints<false,asn::one<40>>;
218 static constexpr const char* name() {return "usable_abs_pattern_info_t";}
219 using parent_t = asn::bstring<>;
223 usable_abs_pattern_info_t& ref_usable_abs_pattern_info() {return usable_abs_pattern_info;}
224 usable_abs_pattern_info_t const& ref_usable_abs_pattern_info() const {return usable_abs_pattern_info;}
225 struct iE_Extensions_t : ProtocolExtensionContainer<UsableABSInformationFDD_ExtIEs>
227 static constexpr const char* name() {return "iE_Extensions_t";}
228 using parent_t = ProtocolExtensionContainer<UsableABSInformationFDD_ExtIEs>;
229 static constexpr bool optional = true;
232 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
233 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
234 template<typename V> void decode(V& v)
236 v(usable_abs_pattern_info);
240 template<typename V> void encode(V& v) const
242 v(usable_abs_pattern_info);
248 usable_abs_pattern_info.clear();
249 iE_Extensions.clear();
253 usable_abs_pattern_info_t usable_abs_pattern_info;
254 iE_Extensions_t iE_Extensions;
258 UsableABSInformationTDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
263 struct UsableABSInformationTDD_ExtIEs
265 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
267 size_t get_index() const {return type;}
268 bool is_unknown() const { return type == 1; }
269 void clear() {type = 0;}
270 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
271 template<typename V> bool decode(V& v)
274 if(!v(ref_nested())) return false;
275 { type = 1; return true;}
279 template<typename V> bool encode(V& v) const
281 return v(ref_nested());
285 template<typename V> bool decode(size_t index, V& v)
290 case 1: type = 1; return v(ref_nested());
291 ref_nested().clear();
296 template<typename V> bool encode(size_t index, V& v) const
298 if(index != type) {return false;} return v(ref_nested());
305 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
307 size_t get_index() const {return type;}
308 bool is_unknown() const { return type == 1; }
309 void clear() {type = 0;}
310 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
311 template<typename V> bool decode(V& v)
314 if(!v(ref_nested())) return false;
315 { type = 1; return true;}
319 template<typename V> bool encode(V& v) const
321 return v(ref_nested());
325 template<typename V> bool decode(size_t index, V& v)
330 case 1: type = 1; return v(ref_nested());
331 ref_nested().clear();
336 template<typename V> bool encode(size_t index, V& v) const
338 if(index != type) {return false;} return v(ref_nested());
345 struct Extension_t : asn::typefield<true>
347 ~Extension_t() {clear();}
348 size_t get_index() const {return type;}
349 bool is_unknown() const { return type == 1; }
352 type = 0; ref_nested().clear();
354 template<typename V> static inline void enumerate(V& v)
359 template<typename V> bool decode(size_t index, V& v)
364 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
369 template<typename V> bool encode(size_t index, V& v) const
371 if(index != type) return false;
379 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
381 size_t get_index() const {return type;}
382 bool is_unknown() const { return type == 1; }
383 void clear() {type = 0;}
384 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
385 template<typename V> bool decode(V& v)
388 if(!v(ref_nested())) return false;
389 { type = 1; return true;}
393 template<typename V> bool encode(V& v) const
395 return v(ref_nested());
399 template<typename V> bool decode(size_t index, V& v)
404 case 1: type = 1; return v(ref_nested());
405 ref_nested().clear();
410 template<typename V> bool encode(size_t index, V& v) const
412 if(index != type) {return false;} return v(ref_nested());
422 UsableABSInformationTDD ::= SEQUENCE {
423 usaable-abs-pattern-info BIT STRING (SIZE(1..70, ...)),
424 iE-Extensions ProtocolExtensionContainer { {UsableABSInformationTDD-ExtIEs} } OPTIONAL,
429 struct UsableABSInformationTDD : asn::sequence<2, 0, true, 1>
431 static constexpr const char* name() {return "UsableABSInformationTDD";}
432 using parent_t = asn::sequence<2, 0, true, 1>;
433 struct usaable_abs_pattern_info_t : asn::bstring<>
435 using constraint_t = asn::constraints<true,asn::span<1, 70>>;
436 static constexpr const char* name() {return "usaable_abs_pattern_info_t";}
437 using parent_t = asn::bstring<>;
441 usaable_abs_pattern_info_t& ref_usaable_abs_pattern_info() {return usaable_abs_pattern_info;}
442 usaable_abs_pattern_info_t const& ref_usaable_abs_pattern_info() const {return usaable_abs_pattern_info;}
443 struct iE_Extensions_t : ProtocolExtensionContainer<UsableABSInformationTDD_ExtIEs>
445 static constexpr const char* name() {return "iE_Extensions_t";}
446 using parent_t = ProtocolExtensionContainer<UsableABSInformationTDD_ExtIEs>;
447 static constexpr bool optional = true;
450 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
451 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
452 template<typename V> void decode(V& v)
454 v(usaable_abs_pattern_info);
458 template<typename V> void encode(V& v) const
460 v(usaable_abs_pattern_info);
466 usaable_abs_pattern_info.clear();
467 iE_Extensions.clear();
471 usaable_abs_pattern_info_t usaable_abs_pattern_info;
472 iE_Extensions_t iE_Extensions;
476 UsableABSInformation ::= CHOICE {
477 fdd UsableABSInformationFDD,
478 tdd UsableABSInformationTDD,
483 struct UsableABSInformation : asn::choice<2, 0, true>
485 static constexpr const char* name() {return "UsableABSInformation";}
486 using parent_t = asn::choice<2, 0, true>;
487 index_type get_index() const {return index;}
488 bool is_unknown() const {return index == 3;}
489 void set_unknown() { set_index(3); }
490 ~UsableABSInformation() {clear();}
491 struct fdd_t : UsableABSInformationFDD
493 static constexpr const char* name() {return "fdd_t";}
494 using parent_t = UsableABSInformationFDD;
497 struct tdd_t : UsableABSInformationTDD
499 static constexpr const char* name() {return "tdd_t";}
500 using parent_t = UsableABSInformationTDD;
507 case 1: var.destroy<fdd_t>(); break;
508 case 2: var.destroy<tdd_t>(); break;
513 template<typename V> bool decode(size_t idx, V& v)
518 case 1: set_index(1); return v(var.build<fdd_t>());
519 case 2: set_index(2); return v(var.build<tdd_t>());
524 template<typename V> bool encode(V& v) const
528 case 1: return v(var.as<fdd_t>());
529 case 2: return v(var.as<tdd_t>());
533 template<typename V> static inline void enumerate(V& v)
535 v.template operator()<fdd_t>(1);
536 v.template operator()<tdd_t>(2);
539 fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
540 fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
541 tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
542 tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
544 void set_index(index_type i) {index = i; base::set();}
547 char dummy1[sizeof(fdd_t)];
548 char dummy2[sizeof(tdd_t)];
551 asn::variant<sizeof(union_type)> var;
552 index_type index {0};
555 ABS-Status-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
560 struct ABS_Status_ExtIEs
562 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
564 size_t get_index() const {return type;}
565 bool is_unknown() const { return type == 1; }
566 void clear() {type = 0;}
567 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
568 template<typename V> bool decode(V& v)
571 if(!v(ref_nested())) return false;
572 { type = 1; return true;}
576 template<typename V> bool encode(V& v) const
578 return v(ref_nested());
582 template<typename V> bool decode(size_t index, V& v)
587 case 1: type = 1; return v(ref_nested());
588 ref_nested().clear();
593 template<typename V> bool encode(size_t index, V& v) const
595 if(index != type) {return false;} return v(ref_nested());
602 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
604 size_t get_index() const {return type;}
605 bool is_unknown() const { return type == 1; }
606 void clear() {type = 0;}
607 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
608 template<typename V> bool decode(V& v)
611 if(!v(ref_nested())) return false;
612 { type = 1; return true;}
616 template<typename V> bool encode(V& v) const
618 return v(ref_nested());
622 template<typename V> bool decode(size_t index, V& v)
627 case 1: type = 1; return v(ref_nested());
628 ref_nested().clear();
633 template<typename V> bool encode(size_t index, V& v) const
635 if(index != type) {return false;} return v(ref_nested());
642 struct Extension_t : asn::typefield<true>
644 ~Extension_t() {clear();}
645 size_t get_index() const {return type;}
646 bool is_unknown() const { return type == 1; }
649 type = 0; ref_nested().clear();
651 template<typename V> static inline void enumerate(V& v)
656 template<typename V> bool decode(size_t index, V& v)
661 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
666 template<typename V> bool encode(size_t index, V& v) const
668 if(index != type) return false;
676 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
678 size_t get_index() const {return type;}
679 bool is_unknown() const { return type == 1; }
680 void clear() {type = 0;}
681 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
682 template<typename V> bool decode(V& v)
685 if(!v(ref_nested())) return false;
686 { type = 1; return true;}
690 template<typename V> bool encode(V& v) const
692 return v(ref_nested());
696 template<typename V> bool decode(size_t index, V& v)
701 case 1: type = 1; return v(ref_nested());
702 ref_nested().clear();
707 template<typename V> bool encode(size_t index, V& v) const
709 if(index != type) {return false;} return v(ref_nested());
719 ABS-Status ::= SEQUENCE {
720 dL-ABS-status DL-ABS-status,
721 usableABSInformation UsableABSInformation,
722 iE-Extensions ProtocolExtensionContainer { {ABS-Status-ExtIEs} } OPTIONAL,
727 struct ABS_Status : asn::sequence<3, 0, true, 1>
729 static constexpr const char* name() {return "ABS-Status";}
730 using parent_t = asn::sequence<3, 0, true, 1>;
731 struct dL_ABS_status_t : DL_ABS_status
733 static constexpr const char* name() {return "dL_ABS_status_t";}
734 using parent_t = DL_ABS_status;
737 dL_ABS_status_t& ref_dL_ABS_status() {return dL_ABS_status;}
738 dL_ABS_status_t const& ref_dL_ABS_status() const {return dL_ABS_status;}
739 struct usableABSInformation_t : UsableABSInformation
741 static constexpr const char* name() {return "usableABSInformation_t";}
742 using parent_t = UsableABSInformation;
745 usableABSInformation_t& ref_usableABSInformation() {return usableABSInformation;}
746 usableABSInformation_t const& ref_usableABSInformation() const {return usableABSInformation;}
747 struct iE_Extensions_t : ProtocolExtensionContainer<ABS_Status_ExtIEs>
749 static constexpr const char* name() {return "iE_Extensions_t";}
750 using parent_t = ProtocolExtensionContainer<ABS_Status_ExtIEs>;
751 static constexpr bool optional = true;
754 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
755 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
756 template<typename V> void decode(V& v)
759 v(usableABSInformation);
763 template<typename V> void encode(V& v) const
766 v(usableABSInformation);
772 dL_ABS_status.clear();
773 usableABSInformation.clear();
774 iE_Extensions.clear();
778 dL_ABS_status_t dL_ABS_status;
779 usableABSInformation_t usableABSInformation;
780 iE_Extensions_t iE_Extensions;
784 ABSInformationFDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
789 struct ABSInformationFDD_ExtIEs
791 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
793 size_t get_index() const {return type;}
794 bool is_unknown() const { return type == 1; }
795 void clear() {type = 0;}
796 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
797 template<typename V> bool decode(V& v)
800 if(!v(ref_nested())) return false;
801 { type = 1; return true;}
805 template<typename V> bool encode(V& v) const
807 return v(ref_nested());
811 template<typename V> bool decode(size_t index, V& v)
816 case 1: type = 1; return v(ref_nested());
817 ref_nested().clear();
822 template<typename V> bool encode(size_t index, V& v) const
824 if(index != type) {return false;} return v(ref_nested());
831 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
833 size_t get_index() const {return type;}
834 bool is_unknown() const { return type == 1; }
835 void clear() {type = 0;}
836 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
837 template<typename V> bool decode(V& v)
840 if(!v(ref_nested())) return false;
841 { type = 1; return true;}
845 template<typename V> bool encode(V& v) const
847 return v(ref_nested());
851 template<typename V> bool decode(size_t index, V& v)
856 case 1: type = 1; return v(ref_nested());
857 ref_nested().clear();
862 template<typename V> bool encode(size_t index, V& v) const
864 if(index != type) {return false;} return v(ref_nested());
871 struct Extension_t : asn::typefield<true>
873 ~Extension_t() {clear();}
874 size_t get_index() const {return type;}
875 bool is_unknown() const { return type == 1; }
878 type = 0; ref_nested().clear();
880 template<typename V> static inline void enumerate(V& v)
885 template<typename V> bool decode(size_t index, V& v)
890 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
895 template<typename V> bool encode(size_t index, V& v) const
897 if(index != type) return false;
905 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
907 size_t get_index() const {return type;}
908 bool is_unknown() const { return type == 1; }
909 void clear() {type = 0;}
910 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
911 template<typename V> bool decode(V& v)
914 if(!v(ref_nested())) return false;
915 { type = 1; return true;}
919 template<typename V> bool encode(V& v) const
921 return v(ref_nested());
925 template<typename V> bool decode(size_t index, V& v)
930 case 1: type = 1; return v(ref_nested());
931 ref_nested().clear();
936 template<typename V> bool encode(size_t index, V& v) const
938 if(index != type) {return false;} return v(ref_nested());
948 ABSInformationFDD ::= SEQUENCE {
949 abs-pattern-info BIT STRING (SIZE(40)),
950 numberOfCellSpecificAntennaPorts ENUMERATED {one, two, four, ...},
951 measurement-subset BIT STRING (SIZE(40)),
952 iE-Extensions ProtocolExtensionContainer { {ABSInformationFDD-ExtIEs} } OPTIONAL,
957 struct ABSInformationFDD : asn::sequence<4, 0, true, 1>
959 static constexpr const char* name() {return "ABSInformationFDD";}
960 using parent_t = asn::sequence<4, 0, true, 1>;
961 struct abs_pattern_info_t : asn::bstring<>
963 using constraint_t = asn::constraints<false,asn::one<40>>;
964 static constexpr const char* name() {return "abs_pattern_info_t";}
965 using parent_t = asn::bstring<>;
969 abs_pattern_info_t& ref_abs_pattern_info() {return abs_pattern_info;}
970 abs_pattern_info_t const& ref_abs_pattern_info() const {return abs_pattern_info;}
971 struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
973 static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
974 using parent_t = asn::enumerated<3, 0, true>;
983 numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
984 numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
985 struct measurement_subset_t : asn::bstring<>
987 using constraint_t = asn::constraints<false,asn::one<40>>;
988 static constexpr const char* name() {return "measurement_subset_t";}
989 using parent_t = asn::bstring<>;
993 measurement_subset_t& ref_measurement_subset() {return measurement_subset;}
994 measurement_subset_t const& ref_measurement_subset() const {return measurement_subset;}
995 struct iE_Extensions_t : ProtocolExtensionContainer<ABSInformationFDD_ExtIEs>
997 static constexpr const char* name() {return "iE_Extensions_t";}
998 using parent_t = ProtocolExtensionContainer<ABSInformationFDD_ExtIEs>;
999 static constexpr bool optional = true;
1002 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
1003 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
1004 template<typename V> void decode(V& v)
1006 v(abs_pattern_info);
1007 v(numberOfCellSpecificAntennaPorts);
1008 v(measurement_subset);
1012 template<typename V> void encode(V& v) const
1014 v(abs_pattern_info);
1015 v(numberOfCellSpecificAntennaPorts);
1016 v(measurement_subset);
1022 abs_pattern_info.clear();
1023 numberOfCellSpecificAntennaPorts.clear();
1024 measurement_subset.clear();
1025 iE_Extensions.clear();
1029 abs_pattern_info_t abs_pattern_info;
1030 numberOfCellSpecificAntennaPorts_t numberOfCellSpecificAntennaPorts;
1031 measurement_subset_t measurement_subset;
1032 iE_Extensions_t iE_Extensions;
1036 ABSInformationTDD-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1041 struct ABSInformationTDD_ExtIEs
1043 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1045 size_t get_index() const {return type;}
1046 bool is_unknown() const { return type == 1; }
1047 void clear() {type = 0;}
1048 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1049 template<typename V> bool decode(V& v)
1052 if(!v(ref_nested())) return false;
1053 { type = 1; return true;}
1057 template<typename V> bool encode(V& v) const
1059 return v(ref_nested());
1063 template<typename V> bool decode(size_t index, V& v)
1068 case 1: type = 1; return v(ref_nested());
1069 ref_nested().clear();
1074 template<typename V> bool encode(size_t index, V& v) const
1076 if(index != type) {return false;} return v(ref_nested());
1083 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
1085 size_t get_index() const {return type;}
1086 bool is_unknown() const { return type == 1; }
1087 void clear() {type = 0;}
1088 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
1089 template<typename V> bool decode(V& v)
1092 if(!v(ref_nested())) return false;
1093 { type = 1; return true;}
1097 template<typename V> bool encode(V& v) const
1099 return v(ref_nested());
1103 template<typename V> bool decode(size_t index, V& v)
1108 case 1: type = 1; return v(ref_nested());
1109 ref_nested().clear();
1114 template<typename V> bool encode(size_t index, V& v) const
1116 if(index != type) {return false;} return v(ref_nested());
1123 struct Extension_t : asn::typefield<true>
1125 ~Extension_t() {clear();}
1126 size_t get_index() const {return type;}
1127 bool is_unknown() const { return type == 1; }
1130 type = 0; ref_nested().clear();
1132 template<typename V> static inline void enumerate(V& v)
1137 template<typename V> bool decode(size_t index, V& v)
1142 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
1147 template<typename V> bool encode(size_t index, V& v) const
1149 if(index != type) return false;
1157 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
1159 size_t get_index() const {return type;}
1160 bool is_unknown() const { return type == 1; }
1161 void clear() {type = 0;}
1162 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
1163 template<typename V> bool decode(V& v)
1166 if(!v(ref_nested())) return false;
1167 { type = 1; return true;}
1171 template<typename V> bool encode(V& v) const
1173 return v(ref_nested());
1177 template<typename V> bool decode(size_t index, V& v)
1182 case 1: type = 1; return v(ref_nested());
1183 ref_nested().clear();
1188 template<typename V> bool encode(size_t index, V& v) const
1190 if(index != type) {return false;} return v(ref_nested());
1200 ABSInformationTDD ::= SEQUENCE {
1201 abs-pattern-info BIT STRING (SIZE(1..70, ...)),
1202 numberOfCellSpecificAntennaPorts ENUMERATED {one, two, four, ...},
1203 measurement-subset BIT STRING (SIZE(1..70, ...)),
1204 iE-Extensions ProtocolExtensionContainer { {ABSInformationTDD-ExtIEs} } OPTIONAL,
1209 struct ABSInformationTDD : asn::sequence<4, 0, true, 1>
1211 static constexpr const char* name() {return "ABSInformationTDD";}
1212 using parent_t = asn::sequence<4, 0, true, 1>;
1213 struct abs_pattern_info_t : asn::bstring<>
1215 using constraint_t = asn::constraints<true,asn::span<1, 70>>;
1216 static constexpr const char* name() {return "abs_pattern_info_t";}
1217 using parent_t = asn::bstring<>;
1221 abs_pattern_info_t& ref_abs_pattern_info() {return abs_pattern_info;}
1222 abs_pattern_info_t const& ref_abs_pattern_info() const {return abs_pattern_info;}
1223 struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
1225 static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
1226 using parent_t = asn::enumerated<3, 0, true>;
1235 numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
1236 numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
1237 struct measurement_subset_t : asn::bstring<>
1239 using constraint_t = asn::constraints<true,asn::span<1, 70>>;
1240 static constexpr const char* name() {return "measurement_subset_t";}
1241 using parent_t = asn::bstring<>;
1245 measurement_subset_t& ref_measurement_subset() {return measurement_subset;}
1246 measurement_subset_t const& ref_measurement_subset() const {return measurement_subset;}
1247 struct iE_Extensions_t : ProtocolExtensionContainer<ABSInformationTDD_ExtIEs>
1249 static constexpr const char* name() {return "iE_Extensions_t";}
1250 using parent_t = ProtocolExtensionContainer<ABSInformationTDD_ExtIEs>;
1251 static constexpr bool optional = true;
1254 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
1255 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
1256 template<typename V> void decode(V& v)
1258 v(abs_pattern_info);
1259 v(numberOfCellSpecificAntennaPorts);
1260 v(measurement_subset);
1264 template<typename V> void encode(V& v) const
1266 v(abs_pattern_info);
1267 v(numberOfCellSpecificAntennaPorts);
1268 v(measurement_subset);
1274 abs_pattern_info.clear();
1275 numberOfCellSpecificAntennaPorts.clear();
1276 measurement_subset.clear();
1277 iE_Extensions.clear();
1281 abs_pattern_info_t abs_pattern_info;
1282 numberOfCellSpecificAntennaPorts_t numberOfCellSpecificAntennaPorts;
1283 measurement_subset_t measurement_subset;
1284 iE_Extensions_t iE_Extensions;
1288 ABSInformation ::= CHOICE {
1289 fdd ABSInformationFDD,
1290 tdd ABSInformationTDD,
1296 struct ABSInformation : asn::choice<3, 0, true>
1298 static constexpr const char* name() {return "ABSInformation";}
1299 using parent_t = asn::choice<3, 0, true>;
1300 index_type get_index() const {return index;}
1301 bool is_unknown() const {return index == 4;}
1302 void set_unknown() { set_index(4); }
1303 ~ABSInformation() {clear();}
1304 struct fdd_t : ABSInformationFDD
1306 static constexpr const char* name() {return "fdd_t";}
1307 using parent_t = ABSInformationFDD;
1310 struct tdd_t : ABSInformationTDD
1312 static constexpr const char* name() {return "tdd_t";}
1313 using parent_t = ABSInformationTDD;
1316 struct abs_inactive_t : asn::nulltype
1318 static constexpr const char* name() {return "abs_inactive_t";}
1319 using parent_t = asn::nulltype;
1326 case 1: var.destroy<fdd_t>(); break;
1327 case 2: var.destroy<tdd_t>(); break;
1328 case 3: var.destroy<abs_inactive_t>(); break;
1333 template<typename V> bool decode(size_t idx, V& v)
1338 case 1: set_index(1); return v(var.build<fdd_t>());
1339 case 2: set_index(2); return v(var.build<tdd_t>());
1340 case 3: set_index(3); return v(var.build<abs_inactive_t>());
1345 template<typename V> bool encode(V& v) const
1349 case 1: return v(var.as<fdd_t>());
1350 case 2: return v(var.as<tdd_t>());
1351 case 3: return v(var.as<abs_inactive_t>());
1355 template<typename V> static inline void enumerate(V& v)
1357 v.template operator()<fdd_t>(1);
1358 v.template operator()<tdd_t>(2);
1359 v.template operator()<abs_inactive_t>(3);
1362 fdd_t& select_fdd() { if(get_index() != 1) { clear(); set_index(1); return var.build<fdd_t>();} return var.as<fdd_t>();}
1363 fdd_t const* get_fdd() const { if(get_index() == 1) { return &var.as<fdd_t>();} return nullptr; }
1364 tdd_t& select_tdd() { if(get_index() != 2) { clear(); set_index(2); return var.build<tdd_t>();} return var.as<tdd_t>();}
1365 tdd_t const* get_tdd() const { if(get_index() == 2) { return &var.as<tdd_t>();} return nullptr; }
1366 abs_inactive_t& select_abs_inactive() { if(get_index() != 3) { clear(); set_index(3); return var.build<abs_inactive_t>();} return var.as<abs_inactive_t>();}
1367 abs_inactive_t const* get_abs_inactive() const { if(get_index() == 3) { return &var.as<abs_inactive_t>();} return nullptr; }
1369 void set_index(index_type i) {index = i; base::set();}
1372 char dummy1[sizeof(fdd_t)];
1373 char dummy2[sizeof(tdd_t)];
1374 char dummy3[sizeof(abs_inactive_t)];
1377 asn::variant<sizeof(union_type)> var;
1378 index_type index {0};
1381 Key-eNodeB-Star ::= BIT STRING (SIZE(256))
1384 struct Key_eNodeB_Star : asn::bstring<>
1386 using constraint_t = asn::constraints<false,asn::one<256>>;
1387 static constexpr const char* name() {return "Key-eNodeB-Star";}
1388 using parent_t = asn::bstring<>;
1393 NextHopChainingCount ::= INTEGER (0..7)
1396 struct NextHopChainingCount : asn::integer<>
1398 using constraint_t = asn::constraints<false,asn::span<0, 7>>;
1399 static constexpr const char* name() {return "NextHopChainingCount";}
1400 using parent_t = asn::integer<>;
1405 AS-SecurityInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1410 struct AS_SecurityInformation_ExtIEs
1412 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1414 size_t get_index() const {return type;}
1415 bool is_unknown() const { return type == 1; }
1416 void clear() {type = 0;}
1417 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1418 template<typename V> bool decode(V& v)
1421 if(!v(ref_nested())) return false;
1422 { type = 1; return true;}
1426 template<typename V> bool encode(V& v) const
1428 return v(ref_nested());
1432 template<typename V> bool decode(size_t index, V& v)
1437 case 1: type = 1; return v(ref_nested());
1438 ref_nested().clear();
1443 template<typename V> bool encode(size_t index, V& v) const
1445 if(index != type) {return false;} return v(ref_nested());
1452 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
1454 size_t get_index() const {return type;}
1455 bool is_unknown() const { return type == 1; }
1456 void clear() {type = 0;}
1457 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
1458 template<typename V> bool decode(V& v)
1461 if(!v(ref_nested())) return false;
1462 { type = 1; return true;}
1466 template<typename V> bool encode(V& v) const
1468 return v(ref_nested());
1472 template<typename V> bool decode(size_t index, V& v)
1477 case 1: type = 1; return v(ref_nested());
1478 ref_nested().clear();
1483 template<typename V> bool encode(size_t index, V& v) const
1485 if(index != type) {return false;} return v(ref_nested());
1492 struct Extension_t : asn::typefield<true>
1494 ~Extension_t() {clear();}
1495 size_t get_index() const {return type;}
1496 bool is_unknown() const { return type == 1; }
1499 type = 0; ref_nested().clear();
1501 template<typename V> static inline void enumerate(V& v)
1506 template<typename V> bool decode(size_t index, V& v)
1511 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
1516 template<typename V> bool encode(size_t index, V& v) const
1518 if(index != type) return false;
1526 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
1528 size_t get_index() const {return type;}
1529 bool is_unknown() const { return type == 1; }
1530 void clear() {type = 0;}
1531 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
1532 template<typename V> bool decode(V& v)
1535 if(!v(ref_nested())) return false;
1536 { type = 1; return true;}
1540 template<typename V> bool encode(V& v) const
1542 return v(ref_nested());
1546 template<typename V> bool decode(size_t index, V& v)
1551 case 1: type = 1; return v(ref_nested());
1552 ref_nested().clear();
1557 template<typename V> bool encode(size_t index, V& v) const
1559 if(index != type) {return false;} return v(ref_nested());
1569 AS-SecurityInformation ::= SEQUENCE {
1570 key-eNodeB-star Key-eNodeB-Star,
1571 nextHopChainingCount NextHopChainingCount,
1572 iE-Extensions ProtocolExtensionContainer { {AS-SecurityInformation-ExtIEs} } OPTIONAL,
1577 struct AS_SecurityInformation : asn::sequence<3, 0, true, 1>
1579 static constexpr const char* name() {return "AS-SecurityInformation";}
1580 using parent_t = asn::sequence<3, 0, true, 1>;
1581 struct key_eNodeB_star_t : Key_eNodeB_Star
1583 static constexpr const char* name() {return "key_eNodeB_star_t";}
1584 using parent_t = Key_eNodeB_Star;
1587 key_eNodeB_star_t& ref_key_eNodeB_star() {return key_eNodeB_star;}
1588 key_eNodeB_star_t const& ref_key_eNodeB_star() const {return key_eNodeB_star;}
1589 struct nextHopChainingCount_t : NextHopChainingCount
1591 static constexpr const char* name() {return "nextHopChainingCount_t";}
1592 using parent_t = NextHopChainingCount;
1595 nextHopChainingCount_t& ref_nextHopChainingCount() {return nextHopChainingCount;}
1596 nextHopChainingCount_t const& ref_nextHopChainingCount() const {return nextHopChainingCount;}
1597 struct iE_Extensions_t : ProtocolExtensionContainer<AS_SecurityInformation_ExtIEs>
1599 static constexpr const char* name() {return "iE_Extensions_t";}
1600 using parent_t = ProtocolExtensionContainer<AS_SecurityInformation_ExtIEs>;
1601 static constexpr bool optional = true;
1604 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
1605 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
1606 template<typename V> void decode(V& v)
1609 v(nextHopChainingCount);
1613 template<typename V> void encode(V& v) const
1616 v(nextHopChainingCount);
1622 key_eNodeB_star.clear();
1623 nextHopChainingCount.clear();
1624 iE_Extensions.clear();
1628 key_eNodeB_star_t key_eNodeB_star;
1629 nextHopChainingCount_t nextHopChainingCount;
1630 iE_Extensions_t iE_Extensions;
1634 ActivationID ::= INTEGER (0..255)
1637 struct ActivationID : asn::integer<>
1639 using constraint_t = asn::constraints<false,asn::span<0, 255>>;
1640 static constexpr const char* name() {return "ActivationID";}
1641 using parent_t = asn::integer<>;
1646 AdditionalSpecialSubframePatterns ::= ENUMERATED {
1661 struct AdditionalSpecialSubframePatterns : asn::enumerated<10, 0, true>
1663 static constexpr const char* name() {return "AdditionalSpecialSubframePatterns";}
1664 using parent_t = asn::enumerated<10, 0, true>;
1681 CyclicPrefixDL ::= ENUMERATED {
1688 struct CyclicPrefixDL : asn::enumerated<2, 0, true>
1690 static constexpr const char* name() {return "CyclicPrefixDL";}
1691 using parent_t = asn::enumerated<2, 0, true>;
1700 CyclicPrefixUL ::= ENUMERATED {
1707 struct CyclicPrefixUL : asn::enumerated<2, 0, true>
1709 static constexpr const char* name() {return "CyclicPrefixUL";}
1710 using parent_t = asn::enumerated<2, 0, true>;
1719 AdditionalSpecialSubframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1724 struct AdditionalSpecialSubframe_Info_ExtIEs
1726 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1728 size_t get_index() const {return type;}
1729 bool is_unknown() const { return type == 1; }
1730 void clear() {type = 0;}
1731 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1732 template<typename V> bool decode(V& v)
1735 if(!v(ref_nested())) return false;
1736 { type = 1; return true;}
1740 template<typename V> bool encode(V& v) const
1742 return v(ref_nested());
1746 template<typename V> bool decode(size_t index, V& v)
1751 case 1: type = 1; return v(ref_nested());
1752 ref_nested().clear();
1757 template<typename V> bool encode(size_t index, V& v) const
1759 if(index != type) {return false;} return v(ref_nested());
1766 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
1768 size_t get_index() const {return type;}
1769 bool is_unknown() const { return type == 1; }
1770 void clear() {type = 0;}
1771 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
1772 template<typename V> bool decode(V& v)
1775 if(!v(ref_nested())) return false;
1776 { type = 1; return true;}
1780 template<typename V> bool encode(V& v) const
1782 return v(ref_nested());
1786 template<typename V> bool decode(size_t index, V& v)
1791 case 1: type = 1; return v(ref_nested());
1792 ref_nested().clear();
1797 template<typename V> bool encode(size_t index, V& v) const
1799 if(index != type) {return false;} return v(ref_nested());
1806 struct Extension_t : asn::typefield<true>
1808 ~Extension_t() {clear();}
1809 size_t get_index() const {return type;}
1810 bool is_unknown() const { return type == 1; }
1813 type = 0; ref_nested().clear();
1815 template<typename V> static inline void enumerate(V& v)
1820 template<typename V> bool decode(size_t index, V& v)
1825 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
1830 template<typename V> bool encode(size_t index, V& v) const
1832 if(index != type) return false;
1840 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
1842 size_t get_index() const {return type;}
1843 bool is_unknown() const { return type == 1; }
1844 void clear() {type = 0;}
1845 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
1846 template<typename V> bool decode(V& v)
1849 if(!v(ref_nested())) return false;
1850 { type = 1; return true;}
1854 template<typename V> bool encode(V& v) const
1856 return v(ref_nested());
1860 template<typename V> bool decode(size_t index, V& v)
1865 case 1: type = 1; return v(ref_nested());
1866 ref_nested().clear();
1871 template<typename V> bool encode(size_t index, V& v) const
1873 if(index != type) {return false;} return v(ref_nested());
1883 AdditionalSpecialSubframe-Info ::= SEQUENCE {
1884 additionalspecialSubframePatterns AdditionalSpecialSubframePatterns,
1885 cyclicPrefixDL CyclicPrefixDL,
1886 cyclicPrefixUL CyclicPrefixUL,
1887 iE-Extensions ProtocolExtensionContainer { {AdditionalSpecialSubframe-Info-ExtIEs} } OPTIONAL,
1892 struct AdditionalSpecialSubframe_Info : asn::sequence<4, 0, true, 1>
1894 static constexpr const char* name() {return "AdditionalSpecialSubframe-Info";}
1895 using parent_t = asn::sequence<4, 0, true, 1>;
1896 struct additionalspecialSubframePatterns_t : AdditionalSpecialSubframePatterns
1898 static constexpr const char* name() {return "additionalspecialSubframePatterns_t";}
1899 using parent_t = AdditionalSpecialSubframePatterns;
1902 additionalspecialSubframePatterns_t& ref_additionalspecialSubframePatterns() {return additionalspecialSubframePatterns;}
1903 additionalspecialSubframePatterns_t const& ref_additionalspecialSubframePatterns() const {return additionalspecialSubframePatterns;}
1904 struct cyclicPrefixDL_t : CyclicPrefixDL
1906 static constexpr const char* name() {return "cyclicPrefixDL_t";}
1907 using parent_t = CyclicPrefixDL;
1910 cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
1911 cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
1912 struct cyclicPrefixUL_t : CyclicPrefixUL
1914 static constexpr const char* name() {return "cyclicPrefixUL_t";}
1915 using parent_t = CyclicPrefixUL;
1918 cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
1919 cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
1920 struct iE_Extensions_t : ProtocolExtensionContainer<AdditionalSpecialSubframe_Info_ExtIEs>
1922 static constexpr const char* name() {return "iE_Extensions_t";}
1923 using parent_t = ProtocolExtensionContainer<AdditionalSpecialSubframe_Info_ExtIEs>;
1924 static constexpr bool optional = true;
1927 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
1928 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
1929 template<typename V> void decode(V& v)
1931 v(additionalspecialSubframePatterns);
1937 template<typename V> void encode(V& v) const
1939 v(additionalspecialSubframePatterns);
1947 additionalspecialSubframePatterns.clear();
1948 cyclicPrefixDL.clear();
1949 cyclicPrefixUL.clear();
1950 iE_Extensions.clear();
1954 additionalspecialSubframePatterns_t additionalspecialSubframePatterns;
1955 cyclicPrefixDL_t cyclicPrefixDL;
1956 cyclicPrefixUL_t cyclicPrefixUL;
1957 iE_Extensions_t iE_Extensions;
1961 AdditionalSpecialSubframePatternsExtension ::= ENUMERATED {
1967 struct AdditionalSpecialSubframePatternsExtension : asn::enumerated<1, 0, true>
1969 static constexpr const char* name() {return "AdditionalSpecialSubframePatternsExtension";}
1970 using parent_t = asn::enumerated<1, 0, true>;
1978 AdditionalSpecialSubframeExtension-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
1983 struct AdditionalSpecialSubframeExtension_Info_ExtIEs
1985 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
1987 size_t get_index() const {return type;}
1988 bool is_unknown() const { return type == 1; }
1989 void clear() {type = 0;}
1990 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
1991 template<typename V> bool decode(V& v)
1994 if(!v(ref_nested())) return false;
1995 { type = 1; return true;}
1999 template<typename V> bool encode(V& v) const
2001 return v(ref_nested());
2005 template<typename V> bool decode(size_t index, V& v)
2010 case 1: type = 1; return v(ref_nested());
2011 ref_nested().clear();
2016 template<typename V> bool encode(size_t index, V& v) const
2018 if(index != type) {return false;} return v(ref_nested());
2025 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2027 size_t get_index() const {return type;}
2028 bool is_unknown() const { return type == 1; }
2029 void clear() {type = 0;}
2030 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2031 template<typename V> bool decode(V& v)
2034 if(!v(ref_nested())) return false;
2035 { type = 1; return true;}
2039 template<typename V> bool encode(V& v) const
2041 return v(ref_nested());
2045 template<typename V> bool decode(size_t index, V& v)
2050 case 1: type = 1; return v(ref_nested());
2051 ref_nested().clear();
2056 template<typename V> bool encode(size_t index, V& v) const
2058 if(index != type) {return false;} return v(ref_nested());
2065 struct Extension_t : asn::typefield<true>
2067 ~Extension_t() {clear();}
2068 size_t get_index() const {return type;}
2069 bool is_unknown() const { return type == 1; }
2072 type = 0; ref_nested().clear();
2074 template<typename V> static inline void enumerate(V& v)
2079 template<typename V> bool decode(size_t index, V& v)
2084 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
2089 template<typename V> bool encode(size_t index, V& v) const
2091 if(index != type) return false;
2099 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
2101 size_t get_index() const {return type;}
2102 bool is_unknown() const { return type == 1; }
2103 void clear() {type = 0;}
2104 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
2105 template<typename V> bool decode(V& v)
2108 if(!v(ref_nested())) return false;
2109 { type = 1; return true;}
2113 template<typename V> bool encode(V& v) const
2115 return v(ref_nested());
2119 template<typename V> bool decode(size_t index, V& v)
2124 case 1: type = 1; return v(ref_nested());
2125 ref_nested().clear();
2130 template<typename V> bool encode(size_t index, V& v) const
2132 if(index != type) {return false;} return v(ref_nested());
2142 AdditionalSpecialSubframeExtension-Info ::= SEQUENCE {
2143 additionalspecialSubframePatternsExtension AdditionalSpecialSubframePatternsExtension,
2144 cyclicPrefixDL CyclicPrefixDL,
2145 cyclicPrefixUL CyclicPrefixUL,
2146 iE-Extensions ProtocolExtensionContainer { {AdditionalSpecialSubframeExtension-Info-ExtIEs} } OPTIONAL,
2151 struct AdditionalSpecialSubframeExtension_Info : asn::sequence<4, 0, true, 1>
2153 static constexpr const char* name() {return "AdditionalSpecialSubframeExtension-Info";}
2154 using parent_t = asn::sequence<4, 0, true, 1>;
2155 struct additionalspecialSubframePatternsExtension_t : AdditionalSpecialSubframePatternsExtension
2157 static constexpr const char* name() {return "additionalspecialSubframePatternsExtension_t";}
2158 using parent_t = AdditionalSpecialSubframePatternsExtension;
2161 additionalspecialSubframePatternsExtension_t& ref_additionalspecialSubframePatternsExtension() {return additionalspecialSubframePatternsExtension;}
2162 additionalspecialSubframePatternsExtension_t const& ref_additionalspecialSubframePatternsExtension() const {return additionalspecialSubframePatternsExtension;}
2163 struct cyclicPrefixDL_t : CyclicPrefixDL
2165 static constexpr const char* name() {return "cyclicPrefixDL_t";}
2166 using parent_t = CyclicPrefixDL;
2169 cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
2170 cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
2171 struct cyclicPrefixUL_t : CyclicPrefixUL
2173 static constexpr const char* name() {return "cyclicPrefixUL_t";}
2174 using parent_t = CyclicPrefixUL;
2177 cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
2178 cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
2179 struct iE_Extensions_t : ProtocolExtensionContainer<AdditionalSpecialSubframeExtension_Info_ExtIEs>
2181 static constexpr const char* name() {return "iE_Extensions_t";}
2182 using parent_t = ProtocolExtensionContainer<AdditionalSpecialSubframeExtension_Info_ExtIEs>;
2183 static constexpr bool optional = true;
2186 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2187 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2188 template<typename V> void decode(V& v)
2190 v(additionalspecialSubframePatternsExtension);
2196 template<typename V> void encode(V& v) const
2198 v(additionalspecialSubframePatternsExtension);
2206 additionalspecialSubframePatternsExtension.clear();
2207 cyclicPrefixDL.clear();
2208 cyclicPrefixUL.clear();
2209 iE_Extensions.clear();
2213 additionalspecialSubframePatternsExtension_t additionalspecialSubframePatternsExtension;
2214 cyclicPrefixDL_t cyclicPrefixDL;
2215 cyclicPrefixUL_t cyclicPrefixUL;
2216 iE_Extensions_t iE_Extensions;
2220 AerialUEsubscriptionInformation ::= ENUMERATED {
2227 struct AerialUEsubscriptionInformation : asn::enumerated<2, 0, true>
2229 static constexpr const char* name() {return "AerialUEsubscriptionInformation";}
2230 using parent_t = asn::enumerated<2, 0, true>;
2239 PriorityLevel ::= INTEGER { spare (0), highest (1), lowest (14), no-priority (15) } (0..15)
2242 struct PriorityLevel : asn::integer<>
2244 using constraint_t = asn::constraints<false,asn::span<0, 15>>;
2245 static constexpr const char* name() {return "PriorityLevel";}
2246 using parent_t = asn::integer<>;
2247 enum {spare = 0, highest = 1, lowest = 14, no_priority = 15};
2252 Pre-emptionCapability ::= ENUMERATED {
2253 shall-not-trigger-pre-emption,
2254 may-trigger-pre-emption
2258 struct Pre_emptionCapability : asn::enumerated<2, 0, false>
2260 static constexpr const char* name() {return "Pre-emptionCapability";}
2261 using parent_t = asn::enumerated<2, 0, false>;
2263 shall_not_trigger_pre_emption
2264 ,may_trigger_pre_emption
2270 Pre-emptionVulnerability ::= ENUMERATED {
2276 struct Pre_emptionVulnerability : asn::enumerated<2, 0, false>
2278 static constexpr const char* name() {return "Pre-emptionVulnerability";}
2279 using parent_t = asn::enumerated<2, 0, false>;
2288 AllocationAndRetentionPriority-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
2293 struct AllocationAndRetentionPriority_ExtIEs
2295 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
2297 size_t get_index() const {return type;}
2298 bool is_unknown() const { return type == 1; }
2299 void clear() {type = 0;}
2300 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
2301 template<typename V> bool decode(V& v)
2304 if(!v(ref_nested())) return false;
2305 { type = 1; return true;}
2309 template<typename V> bool encode(V& v) const
2311 return v(ref_nested());
2315 template<typename V> bool decode(size_t index, V& v)
2320 case 1: type = 1; return v(ref_nested());
2321 ref_nested().clear();
2326 template<typename V> bool encode(size_t index, V& v) const
2328 if(index != type) {return false;} return v(ref_nested());
2335 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2337 size_t get_index() const {return type;}
2338 bool is_unknown() const { return type == 1; }
2339 void clear() {type = 0;}
2340 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2341 template<typename V> bool decode(V& v)
2344 if(!v(ref_nested())) return false;
2345 { type = 1; return true;}
2349 template<typename V> bool encode(V& v) const
2351 return v(ref_nested());
2355 template<typename V> bool decode(size_t index, V& v)
2360 case 1: type = 1; return v(ref_nested());
2361 ref_nested().clear();
2366 template<typename V> bool encode(size_t index, V& v) const
2368 if(index != type) {return false;} return v(ref_nested());
2375 struct Extension_t : asn::typefield<true>
2377 ~Extension_t() {clear();}
2378 size_t get_index() const {return type;}
2379 bool is_unknown() const { return type == 1; }
2382 type = 0; ref_nested().clear();
2384 template<typename V> static inline void enumerate(V& v)
2389 template<typename V> bool decode(size_t index, V& v)
2394 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
2399 template<typename V> bool encode(size_t index, V& v) const
2401 if(index != type) return false;
2409 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
2411 size_t get_index() const {return type;}
2412 bool is_unknown() const { return type == 1; }
2413 void clear() {type = 0;}
2414 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
2415 template<typename V> bool decode(V& v)
2418 if(!v(ref_nested())) return false;
2419 { type = 1; return true;}
2423 template<typename V> bool encode(V& v) const
2425 return v(ref_nested());
2429 template<typename V> bool decode(size_t index, V& v)
2434 case 1: type = 1; return v(ref_nested());
2435 ref_nested().clear();
2440 template<typename V> bool encode(size_t index, V& v) const
2442 if(index != type) {return false;} return v(ref_nested());
2452 AllocationAndRetentionPriority ::= SEQUENCE {
2453 priorityLevel PriorityLevel,
2454 pre-emptionCapability Pre-emptionCapability,
2455 pre-emptionVulnerability Pre-emptionVulnerability,
2456 iE-Extensions ProtocolExtensionContainer { {AllocationAndRetentionPriority-ExtIEs} } OPTIONAL,
2461 struct AllocationAndRetentionPriority : asn::sequence<4, 0, true, 1>
2463 static constexpr const char* name() {return "AllocationAndRetentionPriority";}
2464 using parent_t = asn::sequence<4, 0, true, 1>;
2465 struct priorityLevel_t : PriorityLevel
2467 static constexpr const char* name() {return "priorityLevel_t";}
2468 using parent_t = PriorityLevel;
2471 priorityLevel_t& ref_priorityLevel() {return priorityLevel;}
2472 priorityLevel_t const& ref_priorityLevel() const {return priorityLevel;}
2473 struct pre_emptionCapability_t : Pre_emptionCapability
2475 static constexpr const char* name() {return "pre_emptionCapability_t";}
2476 using parent_t = Pre_emptionCapability;
2479 pre_emptionCapability_t& ref_pre_emptionCapability() {return pre_emptionCapability;}
2480 pre_emptionCapability_t const& ref_pre_emptionCapability() const {return pre_emptionCapability;}
2481 struct pre_emptionVulnerability_t : Pre_emptionVulnerability
2483 static constexpr const char* name() {return "pre_emptionVulnerability_t";}
2484 using parent_t = Pre_emptionVulnerability;
2487 pre_emptionVulnerability_t& ref_pre_emptionVulnerability() {return pre_emptionVulnerability;}
2488 pre_emptionVulnerability_t const& ref_pre_emptionVulnerability() const {return pre_emptionVulnerability;}
2489 struct iE_Extensions_t : ProtocolExtensionContainer<AllocationAndRetentionPriority_ExtIEs>
2491 static constexpr const char* name() {return "iE_Extensions_t";}
2492 using parent_t = ProtocolExtensionContainer<AllocationAndRetentionPriority_ExtIEs>;
2493 static constexpr bool optional = true;
2496 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2497 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2498 template<typename V> void decode(V& v)
2501 v(pre_emptionCapability);
2502 v(pre_emptionVulnerability);
2506 template<typename V> void encode(V& v) const
2509 v(pre_emptionCapability);
2510 v(pre_emptionVulnerability);
2516 priorityLevel.clear();
2517 pre_emptionCapability.clear();
2518 pre_emptionVulnerability.clear();
2519 iE_Extensions.clear();
2523 priorityLevel_t priorityLevel;
2524 pre_emptionCapability_t pre_emptionCapability;
2525 pre_emptionVulnerability_t pre_emptionVulnerability;
2526 iE_Extensions_t iE_Extensions;
2530 PLMN-Identity ::= OCTET STRING (SIZE(3))
2533 struct PLMN_Identity : asn::ostring<>
2535 using constraint_t = asn::constraints<false,asn::one<3>>;
2536 static constexpr const char* name() {return "PLMN-Identity";}
2537 using parent_t = asn::ostring<>;
2542 EUTRANCellIdentifier ::= BIT STRING (SIZE (28))
2545 struct EUTRANCellIdentifier : asn::bstring<>
2547 using constraint_t = asn::constraints<false,asn::one<28>>;
2548 static constexpr const char* name() {return "EUTRANCellIdentifier";}
2549 using parent_t = asn::bstring<>;
2554 ECGI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
2561 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
2563 size_t get_index() const {return type;}
2564 bool is_unknown() const { return type == 1; }
2565 void clear() {type = 0;}
2566 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
2567 template<typename V> bool decode(V& v)
2570 if(!v(ref_nested())) return false;
2571 { type = 1; return true;}
2575 template<typename V> bool encode(V& v) const
2577 return v(ref_nested());
2581 template<typename V> bool decode(size_t index, V& v)
2586 case 1: type = 1; return v(ref_nested());
2587 ref_nested().clear();
2592 template<typename V> bool encode(size_t index, V& v) const
2594 if(index != type) {return false;} return v(ref_nested());
2601 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2603 size_t get_index() const {return type;}
2604 bool is_unknown() const { return type == 1; }
2605 void clear() {type = 0;}
2606 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2607 template<typename V> bool decode(V& v)
2610 if(!v(ref_nested())) return false;
2611 { type = 1; return true;}
2615 template<typename V> bool encode(V& v) const
2617 return v(ref_nested());
2621 template<typename V> bool decode(size_t index, V& v)
2626 case 1: type = 1; return v(ref_nested());
2627 ref_nested().clear();
2632 template<typename V> bool encode(size_t index, V& v) const
2634 if(index != type) {return false;} return v(ref_nested());
2641 struct Extension_t : asn::typefield<true>
2643 ~Extension_t() {clear();}
2644 size_t get_index() const {return type;}
2645 bool is_unknown() const { return type == 1; }
2648 type = 0; ref_nested().clear();
2650 template<typename V> static inline void enumerate(V& v)
2655 template<typename V> bool decode(size_t index, V& v)
2660 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
2665 template<typename V> bool encode(size_t index, V& v) const
2667 if(index != type) return false;
2675 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
2677 size_t get_index() const {return type;}
2678 bool is_unknown() const { return type == 1; }
2679 void clear() {type = 0;}
2680 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
2681 template<typename V> bool decode(V& v)
2684 if(!v(ref_nested())) return false;
2685 { type = 1; return true;}
2689 template<typename V> bool encode(V& v) const
2691 return v(ref_nested());
2695 template<typename V> bool decode(size_t index, V& v)
2700 case 1: type = 1; return v(ref_nested());
2701 ref_nested().clear();
2706 template<typename V> bool encode(size_t index, V& v) const
2708 if(index != type) {return false;} return v(ref_nested());
2719 pLMN-Identity PLMN-Identity,
2720 eUTRANcellIdentifier EUTRANCellIdentifier,
2721 iE-Extensions ProtocolExtensionContainer { {ECGI-ExtIEs} } OPTIONAL,
2726 struct ECGI : asn::sequence<3, 0, true, 1>
2728 static constexpr const char* name() {return "ECGI";}
2729 using parent_t = asn::sequence<3, 0, true, 1>;
2730 struct pLMN_Identity_t : PLMN_Identity
2732 static constexpr const char* name() {return "pLMN_Identity_t";}
2733 using parent_t = PLMN_Identity;
2736 pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
2737 pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
2738 struct eUTRANcellIdentifier_t : EUTRANCellIdentifier
2740 static constexpr const char* name() {return "eUTRANcellIdentifier_t";}
2741 using parent_t = EUTRANCellIdentifier;
2744 eUTRANcellIdentifier_t& ref_eUTRANcellIdentifier() {return eUTRANcellIdentifier;}
2745 eUTRANcellIdentifier_t const& ref_eUTRANcellIdentifier() const {return eUTRANcellIdentifier;}
2746 struct iE_Extensions_t : ProtocolExtensionContainer<ECGI_ExtIEs>
2748 static constexpr const char* name() {return "iE_Extensions_t";}
2749 using parent_t = ProtocolExtensionContainer<ECGI_ExtIEs>;
2750 static constexpr bool optional = true;
2753 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2754 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2755 template<typename V> void decode(V& v)
2758 v(eUTRANcellIdentifier);
2762 template<typename V> void encode(V& v) const
2765 v(eUTRANcellIdentifier);
2771 pLMN_Identity.clear();
2772 eUTRANcellIdentifier.clear();
2773 iE_Extensions.clear();
2777 pLMN_Identity_t pLMN_Identity;
2778 eUTRANcellIdentifier_t eUTRANcellIdentifier;
2779 iE_Extensions_t iE_Extensions;
2783 CellIdListforMDT ::= SEQUENCE (SIZE(1..maxnoofCellIDforMDT)) OF ECGI
2786 struct CellIdListforMDT_elm : ECGI
2788 static constexpr const char* name() {return "CellIdListforMDT_elm";}
2789 using parent_t = ECGI;
2792 struct CellIdListforMDT : asn::sequenceof<CellIdListforMDT_elm>
2794 static constexpr const char* name() {return "CellIdListforMDT";}
2795 using parent_t = asn::sequenceof<CellIdListforMDT_elm>;
2796 using constraint_t = asn::constraints<false,asn::span<1, maxnoofCellIDforMDT >>;
2800 CellBasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
2805 struct CellBasedMDT_ExtIEs
2807 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
2809 size_t get_index() const {return type;}
2810 bool is_unknown() const { return type == 1; }
2811 void clear() {type = 0;}
2812 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
2813 template<typename V> bool decode(V& v)
2816 if(!v(ref_nested())) return false;
2817 { type = 1; return true;}
2821 template<typename V> bool encode(V& v) const
2823 return v(ref_nested());
2827 template<typename V> bool decode(size_t index, V& v)
2832 case 1: type = 1; return v(ref_nested());
2833 ref_nested().clear();
2838 template<typename V> bool encode(size_t index, V& v) const
2840 if(index != type) {return false;} return v(ref_nested());
2847 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
2849 size_t get_index() const {return type;}
2850 bool is_unknown() const { return type == 1; }
2851 void clear() {type = 0;}
2852 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
2853 template<typename V> bool decode(V& v)
2856 if(!v(ref_nested())) return false;
2857 { type = 1; return true;}
2861 template<typename V> bool encode(V& v) const
2863 return v(ref_nested());
2867 template<typename V> bool decode(size_t index, V& v)
2872 case 1: type = 1; return v(ref_nested());
2873 ref_nested().clear();
2878 template<typename V> bool encode(size_t index, V& v) const
2880 if(index != type) {return false;} return v(ref_nested());
2887 struct Extension_t : asn::typefield<true>
2889 ~Extension_t() {clear();}
2890 size_t get_index() const {return type;}
2891 bool is_unknown() const { return type == 1; }
2894 type = 0; ref_nested().clear();
2896 template<typename V> static inline void enumerate(V& v)
2901 template<typename V> bool decode(size_t index, V& v)
2906 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
2911 template<typename V> bool encode(size_t index, V& v) const
2913 if(index != type) return false;
2921 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
2923 size_t get_index() const {return type;}
2924 bool is_unknown() const { return type == 1; }
2925 void clear() {type = 0;}
2926 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
2927 template<typename V> bool decode(V& v)
2930 if(!v(ref_nested())) return false;
2931 { type = 1; return true;}
2935 template<typename V> bool encode(V& v) const
2937 return v(ref_nested());
2941 template<typename V> bool decode(size_t index, V& v)
2946 case 1: type = 1; return v(ref_nested());
2947 ref_nested().clear();
2952 template<typename V> bool encode(size_t index, V& v) const
2954 if(index != type) {return false;} return v(ref_nested());
2964 CellBasedMDT::= SEQUENCE {
2965 cellIdListforMDT CellIdListforMDT,
2966 iE-Extensions ProtocolExtensionContainer { {CellBasedMDT-ExtIEs} } OPTIONAL,
2971 struct CellBasedMDT : asn::sequence<2, 0, true, 1>
2973 static constexpr const char* name() {return "CellBasedMDT";}
2974 using parent_t = asn::sequence<2, 0, true, 1>;
2975 struct cellIdListforMDT_t : CellIdListforMDT
2977 static constexpr const char* name() {return "cellIdListforMDT_t";}
2978 using parent_t = CellIdListforMDT;
2981 cellIdListforMDT_t& ref_cellIdListforMDT() {return cellIdListforMDT;}
2982 cellIdListforMDT_t const& ref_cellIdListforMDT() const {return cellIdListforMDT;}
2983 struct iE_Extensions_t : ProtocolExtensionContainer<CellBasedMDT_ExtIEs>
2985 static constexpr const char* name() {return "iE_Extensions_t";}
2986 using parent_t = ProtocolExtensionContainer<CellBasedMDT_ExtIEs>;
2987 static constexpr bool optional = true;
2990 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
2991 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
2992 template<typename V> void decode(V& v)
2994 v(cellIdListforMDT);
2998 template<typename V> void encode(V& v) const
3000 v(cellIdListforMDT);
3006 cellIdListforMDT.clear();
3007 iE_Extensions.clear();
3011 cellIdListforMDT_t cellIdListforMDT;
3012 iE_Extensions_t iE_Extensions;
3016 TAC ::= OCTET STRING (SIZE (2))
3019 struct TAC : asn::ostring<>
3021 using constraint_t = asn::constraints<false,asn::one<2>>;
3022 static constexpr const char* name() {return "TAC";}
3023 using parent_t = asn::ostring<>;
3028 TAListforMDT ::= SEQUENCE (SIZE(1..maxnoofTAforMDT)) OF TAC
3031 struct TAListforMDT_elm : TAC
3033 static constexpr const char* name() {return "TAListforMDT_elm";}
3034 using parent_t = TAC;
3037 struct TAListforMDT : asn::sequenceof<TAListforMDT_elm>
3039 static constexpr const char* name() {return "TAListforMDT";}
3040 using parent_t = asn::sequenceof<TAListforMDT_elm>;
3041 using constraint_t = asn::constraints<false,asn::span<1, maxnoofTAforMDT >>;
3045 TABasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3050 struct TABasedMDT_ExtIEs
3052 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3054 size_t get_index() const {return type;}
3055 bool is_unknown() const { return type == 1; }
3056 void clear() {type = 0;}
3057 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3058 template<typename V> bool decode(V& v)
3061 if(!v(ref_nested())) return false;
3062 { type = 1; return true;}
3066 template<typename V> bool encode(V& v) const
3068 return v(ref_nested());
3072 template<typename V> bool decode(size_t index, V& v)
3077 case 1: type = 1; return v(ref_nested());
3078 ref_nested().clear();
3083 template<typename V> bool encode(size_t index, V& v) const
3085 if(index != type) {return false;} return v(ref_nested());
3092 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3094 size_t get_index() const {return type;}
3095 bool is_unknown() const { return type == 1; }
3096 void clear() {type = 0;}
3097 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3098 template<typename V> bool decode(V& v)
3101 if(!v(ref_nested())) return false;
3102 { type = 1; return true;}
3106 template<typename V> bool encode(V& v) const
3108 return v(ref_nested());
3112 template<typename V> bool decode(size_t index, V& v)
3117 case 1: type = 1; return v(ref_nested());
3118 ref_nested().clear();
3123 template<typename V> bool encode(size_t index, V& v) const
3125 if(index != type) {return false;} return v(ref_nested());
3132 struct Extension_t : asn::typefield<true>
3134 ~Extension_t() {clear();}
3135 size_t get_index() const {return type;}
3136 bool is_unknown() const { return type == 1; }
3139 type = 0; ref_nested().clear();
3141 template<typename V> static inline void enumerate(V& v)
3146 template<typename V> bool decode(size_t index, V& v)
3151 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3156 template<typename V> bool encode(size_t index, V& v) const
3158 if(index != type) return false;
3166 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3168 size_t get_index() const {return type;}
3169 bool is_unknown() const { return type == 1; }
3170 void clear() {type = 0;}
3171 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3172 template<typename V> bool decode(V& v)
3175 if(!v(ref_nested())) return false;
3176 { type = 1; return true;}
3180 template<typename V> bool encode(V& v) const
3182 return v(ref_nested());
3186 template<typename V> bool decode(size_t index, V& v)
3191 case 1: type = 1; return v(ref_nested());
3192 ref_nested().clear();
3197 template<typename V> bool encode(size_t index, V& v) const
3199 if(index != type) {return false;} return v(ref_nested());
3209 TABasedMDT::= SEQUENCE {
3210 tAListforMDT TAListforMDT,
3211 iE-Extensions ProtocolExtensionContainer { {TABasedMDT-ExtIEs} } OPTIONAL,
3216 struct TABasedMDT : asn::sequence<2, 0, true, 1>
3218 static constexpr const char* name() {return "TABasedMDT";}
3219 using parent_t = asn::sequence<2, 0, true, 1>;
3220 struct tAListforMDT_t : TAListforMDT
3222 static constexpr const char* name() {return "tAListforMDT_t";}
3223 using parent_t = TAListforMDT;
3226 tAListforMDT_t& ref_tAListforMDT() {return tAListforMDT;}
3227 tAListforMDT_t const& ref_tAListforMDT() const {return tAListforMDT;}
3228 struct iE_Extensions_t : ProtocolExtensionContainer<TABasedMDT_ExtIEs>
3230 static constexpr const char* name() {return "iE_Extensions_t";}
3231 using parent_t = ProtocolExtensionContainer<TABasedMDT_ExtIEs>;
3232 static constexpr bool optional = true;
3235 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3236 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3237 template<typename V> void decode(V& v)
3243 template<typename V> void encode(V& v) const
3251 tAListforMDT.clear();
3252 iE_Extensions.clear();
3256 tAListforMDT_t tAListforMDT;
3257 iE_Extensions_t iE_Extensions;
3261 TAI-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3266 struct TAI_Item_ExtIEs
3268 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3270 size_t get_index() const {return type;}
3271 bool is_unknown() const { return type == 1; }
3272 void clear() {type = 0;}
3273 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3274 template<typename V> bool decode(V& v)
3277 if(!v(ref_nested())) return false;
3278 { type = 1; return true;}
3282 template<typename V> bool encode(V& v) const
3284 return v(ref_nested());
3288 template<typename V> bool decode(size_t index, V& v)
3293 case 1: type = 1; return v(ref_nested());
3294 ref_nested().clear();
3299 template<typename V> bool encode(size_t index, V& v) const
3301 if(index != type) {return false;} return v(ref_nested());
3308 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3310 size_t get_index() const {return type;}
3311 bool is_unknown() const { return type == 1; }
3312 void clear() {type = 0;}
3313 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3314 template<typename V> bool decode(V& v)
3317 if(!v(ref_nested())) return false;
3318 { type = 1; return true;}
3322 template<typename V> bool encode(V& v) const
3324 return v(ref_nested());
3328 template<typename V> bool decode(size_t index, V& v)
3333 case 1: type = 1; return v(ref_nested());
3334 ref_nested().clear();
3339 template<typename V> bool encode(size_t index, V& v) const
3341 if(index != type) {return false;} return v(ref_nested());
3348 struct Extension_t : asn::typefield<true>
3350 ~Extension_t() {clear();}
3351 size_t get_index() const {return type;}
3352 bool is_unknown() const { return type == 1; }
3355 type = 0; ref_nested().clear();
3357 template<typename V> static inline void enumerate(V& v)
3362 template<typename V> bool decode(size_t index, V& v)
3367 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3372 template<typename V> bool encode(size_t index, V& v) const
3374 if(index != type) return false;
3382 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3384 size_t get_index() const {return type;}
3385 bool is_unknown() const { return type == 1; }
3386 void clear() {type = 0;}
3387 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3388 template<typename V> bool decode(V& v)
3391 if(!v(ref_nested())) return false;
3392 { type = 1; return true;}
3396 template<typename V> bool encode(V& v) const
3398 return v(ref_nested());
3402 template<typename V> bool decode(size_t index, V& v)
3407 case 1: type = 1; return v(ref_nested());
3408 ref_nested().clear();
3413 template<typename V> bool encode(size_t index, V& v) const
3415 if(index != type) {return false;} return v(ref_nested());
3425 TAI-Item ::= SEQUENCE {
3427 pLMN-Identity PLMN-Identity,
3428 iE-Extensions ProtocolExtensionContainer { {TAI-Item-ExtIEs} } OPTIONAL,
3433 struct TAI_Item : asn::sequence<3, 0, true, 1>
3435 static constexpr const char* name() {return "TAI-Item";}
3436 using parent_t = asn::sequence<3, 0, true, 1>;
3439 static constexpr const char* name() {return "tAC_t";}
3440 using parent_t = TAC;
3443 tAC_t& ref_tAC() {return tAC;}
3444 tAC_t const& ref_tAC() const {return tAC;}
3445 struct pLMN_Identity_t : PLMN_Identity
3447 static constexpr const char* name() {return "pLMN_Identity_t";}
3448 using parent_t = PLMN_Identity;
3451 pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
3452 pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
3453 struct iE_Extensions_t : ProtocolExtensionContainer<TAI_Item_ExtIEs>
3455 static constexpr const char* name() {return "iE_Extensions_t";}
3456 using parent_t = ProtocolExtensionContainer<TAI_Item_ExtIEs>;
3457 static constexpr bool optional = true;
3460 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3461 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3462 template<typename V> void decode(V& v)
3469 template<typename V> void encode(V& v) const
3479 pLMN_Identity.clear();
3480 iE_Extensions.clear();
3485 pLMN_Identity_t pLMN_Identity;
3486 iE_Extensions_t iE_Extensions;
3490 TAIListforMDT ::= SEQUENCE (SIZE(1..maxnoofTAforMDT)) OF TAI-Item
3493 struct TAIListforMDT_elm : TAI_Item
3495 static constexpr const char* name() {return "TAIListforMDT_elm";}
3496 using parent_t = TAI_Item;
3499 struct TAIListforMDT : asn::sequenceof<TAIListforMDT_elm>
3501 static constexpr const char* name() {return "TAIListforMDT";}
3502 using parent_t = asn::sequenceof<TAIListforMDT_elm>;
3503 using constraint_t = asn::constraints<false,asn::span<1, maxnoofTAforMDT >>;
3507 TAIBasedMDT-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3512 struct TAIBasedMDT_ExtIEs
3514 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3516 size_t get_index() const {return type;}
3517 bool is_unknown() const { return type == 1; }
3518 void clear() {type = 0;}
3519 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3520 template<typename V> bool decode(V& v)
3523 if(!v(ref_nested())) return false;
3524 { type = 1; return true;}
3528 template<typename V> bool encode(V& v) const
3530 return v(ref_nested());
3534 template<typename V> bool decode(size_t index, V& v)
3539 case 1: type = 1; return v(ref_nested());
3540 ref_nested().clear();
3545 template<typename V> bool encode(size_t index, V& v) const
3547 if(index != type) {return false;} return v(ref_nested());
3554 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3556 size_t get_index() const {return type;}
3557 bool is_unknown() const { return type == 1; }
3558 void clear() {type = 0;}
3559 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3560 template<typename V> bool decode(V& v)
3563 if(!v(ref_nested())) return false;
3564 { type = 1; return true;}
3568 template<typename V> bool encode(V& v) const
3570 return v(ref_nested());
3574 template<typename V> bool decode(size_t index, V& v)
3579 case 1: type = 1; return v(ref_nested());
3580 ref_nested().clear();
3585 template<typename V> bool encode(size_t index, V& v) const
3587 if(index != type) {return false;} return v(ref_nested());
3594 struct Extension_t : asn::typefield<true>
3596 ~Extension_t() {clear();}
3597 size_t get_index() const {return type;}
3598 bool is_unknown() const { return type == 1; }
3601 type = 0; ref_nested().clear();
3603 template<typename V> static inline void enumerate(V& v)
3608 template<typename V> bool decode(size_t index, V& v)
3613 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3618 template<typename V> bool encode(size_t index, V& v) const
3620 if(index != type) return false;
3628 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3630 size_t get_index() const {return type;}
3631 bool is_unknown() const { return type == 1; }
3632 void clear() {type = 0;}
3633 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3634 template<typename V> bool decode(V& v)
3637 if(!v(ref_nested())) return false;
3638 { type = 1; return true;}
3642 template<typename V> bool encode(V& v) const
3644 return v(ref_nested());
3648 template<typename V> bool decode(size_t index, V& v)
3653 case 1: type = 1; return v(ref_nested());
3654 ref_nested().clear();
3659 template<typename V> bool encode(size_t index, V& v) const
3661 if(index != type) {return false;} return v(ref_nested());
3671 TAIBasedMDT ::= SEQUENCE {
3672 tAIListforMDT TAIListforMDT,
3673 iE-Extensions ProtocolExtensionContainer { {TAIBasedMDT-ExtIEs} } OPTIONAL,
3678 struct TAIBasedMDT : asn::sequence<2, 0, true, 1>
3680 static constexpr const char* name() {return "TAIBasedMDT";}
3681 using parent_t = asn::sequence<2, 0, true, 1>;
3682 struct tAIListforMDT_t : TAIListforMDT
3684 static constexpr const char* name() {return "tAIListforMDT_t";}
3685 using parent_t = TAIListforMDT;
3688 tAIListforMDT_t& ref_tAIListforMDT() {return tAIListforMDT;}
3689 tAIListforMDT_t const& ref_tAIListforMDT() const {return tAIListforMDT;}
3690 struct iE_Extensions_t : ProtocolExtensionContainer<TAIBasedMDT_ExtIEs>
3692 static constexpr const char* name() {return "iE_Extensions_t";}
3693 using parent_t = ProtocolExtensionContainer<TAIBasedMDT_ExtIEs>;
3694 static constexpr bool optional = true;
3697 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
3698 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
3699 template<typename V> void decode(V& v)
3705 template<typename V> void encode(V& v) const
3713 tAIListforMDT.clear();
3714 iE_Extensions.clear();
3718 tAIListforMDT_t tAIListforMDT;
3719 iE_Extensions_t iE_Extensions;
3723 AreaScopeOfMDT ::= CHOICE {
3724 cellBased CellBasedMDT,
3728 tAIBased TAIBasedMDT
3732 struct AreaScopeOfMDT : asn::choice<4, 1, true>
3734 static constexpr const char* name() {return "AreaScopeOfMDT";}
3735 using parent_t = asn::choice<4, 1, true>;
3736 index_type get_index() const {return index;}
3737 bool is_unknown() const {return index == 5;}
3738 void set_unknown() { set_index(5); }
3739 ~AreaScopeOfMDT() {clear();}
3740 struct cellBased_t : CellBasedMDT
3742 static constexpr const char* name() {return "cellBased_t";}
3743 using parent_t = CellBasedMDT;
3746 struct tABased_t : TABasedMDT
3748 static constexpr const char* name() {return "tABased_t";}
3749 using parent_t = TABasedMDT;
3752 struct pLMNWide_t : asn::nulltype
3754 static constexpr const char* name() {return "pLMNWide_t";}
3755 using parent_t = asn::nulltype;
3758 struct tAIBased_t : TAIBasedMDT
3760 static constexpr const char* name() {return "tAIBased_t";}
3761 using parent_t = TAIBasedMDT;
3768 case 1: var.destroy<cellBased_t>(); break;
3769 case 2: var.destroy<tABased_t>(); break;
3770 case 3: var.destroy<pLMNWide_t>(); break;
3771 case 4: var.destroy<tAIBased_t>(); break;
3776 template<typename V> bool decode(size_t idx, V& v)
3781 case 1: set_index(1); return v(var.build<cellBased_t>());
3782 case 2: set_index(2); return v(var.build<tABased_t>());
3783 case 3: set_index(3); return v(var.build<pLMNWide_t>());
3784 case 4: set_index(4); return v(var.build<tAIBased_t>());
3789 template<typename V> bool encode(V& v) const
3793 case 1: return v(var.as<cellBased_t>());
3794 case 2: return v(var.as<tABased_t>());
3795 case 3: return v(var.as<pLMNWide_t>());
3796 case 4: return v(var.as<tAIBased_t>());
3800 template<typename V> static inline void enumerate(V& v)
3802 v.template operator()<cellBased_t>(1);
3803 v.template operator()<tABased_t>(2);
3804 v.template operator()<pLMNWide_t>(3);
3805 v.template operator()<tAIBased_t>(4);
3808 cellBased_t& select_cellBased() { if(get_index() != 1) { clear(); set_index(1); return var.build<cellBased_t>();} return var.as<cellBased_t>();}
3809 cellBased_t const* get_cellBased() const { if(get_index() == 1) { return &var.as<cellBased_t>();} return nullptr; }
3810 tABased_t& select_tABased() { if(get_index() != 2) { clear(); set_index(2); return var.build<tABased_t>();} return var.as<tABased_t>();}
3811 tABased_t const* get_tABased() const { if(get_index() == 2) { return &var.as<tABased_t>();} return nullptr; }
3812 pLMNWide_t& select_pLMNWide() { if(get_index() != 3) { clear(); set_index(3); return var.build<pLMNWide_t>();} return var.as<pLMNWide_t>();}
3813 pLMNWide_t const* get_pLMNWide() const { if(get_index() == 3) { return &var.as<pLMNWide_t>();} return nullptr; }
3814 tAIBased_t& select_tAIBased() { if(get_index() != 4) { clear(); set_index(4); return var.build<tAIBased_t>();} return var.as<tAIBased_t>();}
3815 tAIBased_t const* get_tAIBased() const { if(get_index() == 4) { return &var.as<tAIBased_t>();} return nullptr; }
3817 void set_index(index_type i) {index = i; base::set();}
3820 char dummy1[sizeof(cellBased_t)];
3821 char dummy2[sizeof(tABased_t)];
3822 char dummy3[sizeof(pLMNWide_t)];
3823 char dummy4[sizeof(tAIBased_t)];
3826 asn::variant<sizeof(union_type)> var;
3827 index_type index {0};
3830 CellIdListforQMC ::= SEQUENCE (SIZE(1..maxnoofCellIDforQMC)) OF ECGI
3833 struct CellIdListforQMC_elm : ECGI
3835 static constexpr const char* name() {return "CellIdListforQMC_elm";}
3836 using parent_t = ECGI;
3839 struct CellIdListforQMC : asn::sequenceof<CellIdListforQMC_elm>
3841 static constexpr const char* name() {return "CellIdListforQMC";}
3842 using parent_t = asn::sequenceof<CellIdListforQMC_elm>;
3843 using constraint_t = asn::constraints<false,asn::span<1, maxnoofCellIDforQMC >>;
3847 CellBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
3852 struct CellBasedQMC_ExtIEs
3854 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
3856 size_t get_index() const {return type;}
3857 bool is_unknown() const { return type == 1; }
3858 void clear() {type = 0;}
3859 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
3860 template<typename V> bool decode(V& v)
3863 if(!v(ref_nested())) return false;
3864 { type = 1; return true;}
3868 template<typename V> bool encode(V& v) const
3870 return v(ref_nested());
3874 template<typename V> bool decode(size_t index, V& v)
3879 case 1: type = 1; return v(ref_nested());
3880 ref_nested().clear();
3885 template<typename V> bool encode(size_t index, V& v) const
3887 if(index != type) {return false;} return v(ref_nested());
3894 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
3896 size_t get_index() const {return type;}
3897 bool is_unknown() const { return type == 1; }
3898 void clear() {type = 0;}
3899 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
3900 template<typename V> bool decode(V& v)
3903 if(!v(ref_nested())) return false;
3904 { type = 1; return true;}
3908 template<typename V> bool encode(V& v) const
3910 return v(ref_nested());
3914 template<typename V> bool decode(size_t index, V& v)
3919 case 1: type = 1; return v(ref_nested());
3920 ref_nested().clear();
3925 template<typename V> bool encode(size_t index, V& v) const
3927 if(index != type) {return false;} return v(ref_nested());
3934 struct Extension_t : asn::typefield<true>
3936 ~Extension_t() {clear();}
3937 size_t get_index() const {return type;}
3938 bool is_unknown() const { return type == 1; }
3941 type = 0; ref_nested().clear();
3943 template<typename V> static inline void enumerate(V& v)
3948 template<typename V> bool decode(size_t index, V& v)
3953 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
3958 template<typename V> bool encode(size_t index, V& v) const
3960 if(index != type) return false;
3968 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
3970 size_t get_index() const {return type;}
3971 bool is_unknown() const { return type == 1; }
3972 void clear() {type = 0;}
3973 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
3974 template<typename V> bool decode(V& v)
3977 if(!v(ref_nested())) return false;
3978 { type = 1; return true;}
3982 template<typename V> bool encode(V& v) const
3984 return v(ref_nested());
3988 template<typename V> bool decode(size_t index, V& v)
3993 case 1: type = 1; return v(ref_nested());
3994 ref_nested().clear();
3999 template<typename V> bool encode(size_t index, V& v) const
4001 if(index != type) {return false;} return v(ref_nested());
4011 CellBasedQMC::= SEQUENCE {
4012 cellIdListforQMC CellIdListforQMC,
4013 iE-Extensions ProtocolExtensionContainer { {CellBasedQMC-ExtIEs} } OPTIONAL,
4018 struct CellBasedQMC : asn::sequence<2, 0, true, 1>
4020 static constexpr const char* name() {return "CellBasedQMC";}
4021 using parent_t = asn::sequence<2, 0, true, 1>;
4022 struct cellIdListforQMC_t : CellIdListforQMC
4024 static constexpr const char* name() {return "cellIdListforQMC_t";}
4025 using parent_t = CellIdListforQMC;
4028 cellIdListforQMC_t& ref_cellIdListforQMC() {return cellIdListforQMC;}
4029 cellIdListforQMC_t const& ref_cellIdListforQMC() const {return cellIdListforQMC;}
4030 struct iE_Extensions_t : ProtocolExtensionContainer<CellBasedQMC_ExtIEs>
4032 static constexpr const char* name() {return "iE_Extensions_t";}
4033 using parent_t = ProtocolExtensionContainer<CellBasedQMC_ExtIEs>;
4034 static constexpr bool optional = true;
4037 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
4038 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
4039 template<typename V> void decode(V& v)
4041 v(cellIdListforQMC);
4045 template<typename V> void encode(V& v) const
4047 v(cellIdListforQMC);
4053 cellIdListforQMC.clear();
4054 iE_Extensions.clear();
4058 cellIdListforQMC_t cellIdListforQMC;
4059 iE_Extensions_t iE_Extensions;
4063 TAListforQMC ::= SEQUENCE (SIZE(1..maxnoofTAforQMC)) OF TAC
4066 struct TAListforQMC_elm : TAC
4068 static constexpr const char* name() {return "TAListforQMC_elm";}
4069 using parent_t = TAC;
4072 struct TAListforQMC : asn::sequenceof<TAListforQMC_elm>
4074 static constexpr const char* name() {return "TAListforQMC";}
4075 using parent_t = asn::sequenceof<TAListforQMC_elm>;
4076 using constraint_t = asn::constraints<false,asn::span<1, maxnoofTAforQMC >>;
4080 TABasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4085 struct TABasedQMC_ExtIEs
4087 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4089 size_t get_index() const {return type;}
4090 bool is_unknown() const { return type == 1; }
4091 void clear() {type = 0;}
4092 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4093 template<typename V> bool decode(V& v)
4096 if(!v(ref_nested())) return false;
4097 { type = 1; return true;}
4101 template<typename V> bool encode(V& v) const
4103 return v(ref_nested());
4107 template<typename V> bool decode(size_t index, V& v)
4112 case 1: type = 1; return v(ref_nested());
4113 ref_nested().clear();
4118 template<typename V> bool encode(size_t index, V& v) const
4120 if(index != type) {return false;} return v(ref_nested());
4127 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4129 size_t get_index() const {return type;}
4130 bool is_unknown() const { return type == 1; }
4131 void clear() {type = 0;}
4132 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4133 template<typename V> bool decode(V& v)
4136 if(!v(ref_nested())) return false;
4137 { type = 1; return true;}
4141 template<typename V> bool encode(V& v) const
4143 return v(ref_nested());
4147 template<typename V> bool decode(size_t index, V& v)
4152 case 1: type = 1; return v(ref_nested());
4153 ref_nested().clear();
4158 template<typename V> bool encode(size_t index, V& v) const
4160 if(index != type) {return false;} return v(ref_nested());
4167 struct Extension_t : asn::typefield<true>
4169 ~Extension_t() {clear();}
4170 size_t get_index() const {return type;}
4171 bool is_unknown() const { return type == 1; }
4174 type = 0; ref_nested().clear();
4176 template<typename V> static inline void enumerate(V& v)
4181 template<typename V> bool decode(size_t index, V& v)
4186 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4191 template<typename V> bool encode(size_t index, V& v) const
4193 if(index != type) return false;
4201 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
4203 size_t get_index() const {return type;}
4204 bool is_unknown() const { return type == 1; }
4205 void clear() {type = 0;}
4206 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
4207 template<typename V> bool decode(V& v)
4210 if(!v(ref_nested())) return false;
4211 { type = 1; return true;}
4215 template<typename V> bool encode(V& v) const
4217 return v(ref_nested());
4221 template<typename V> bool decode(size_t index, V& v)
4226 case 1: type = 1; return v(ref_nested());
4227 ref_nested().clear();
4232 template<typename V> bool encode(size_t index, V& v) const
4234 if(index != type) {return false;} return v(ref_nested());
4244 TABasedQMC ::= SEQUENCE {
4245 tAListforQMC TAListforQMC,
4246 iE-Extensions ProtocolExtensionContainer { {TABasedQMC-ExtIEs} } OPTIONAL,
4251 struct TABasedQMC : asn::sequence<2, 0, true, 1>
4253 static constexpr const char* name() {return "TABasedQMC";}
4254 using parent_t = asn::sequence<2, 0, true, 1>;
4255 struct tAListforQMC_t : TAListforQMC
4257 static constexpr const char* name() {return "tAListforQMC_t";}
4258 using parent_t = TAListforQMC;
4261 tAListforQMC_t& ref_tAListforQMC() {return tAListforQMC;}
4262 tAListforQMC_t const& ref_tAListforQMC() const {return tAListforQMC;}
4263 struct iE_Extensions_t : ProtocolExtensionContainer<TABasedQMC_ExtIEs>
4265 static constexpr const char* name() {return "iE_Extensions_t";}
4266 using parent_t = ProtocolExtensionContainer<TABasedQMC_ExtIEs>;
4267 static constexpr bool optional = true;
4270 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
4271 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
4272 template<typename V> void decode(V& v)
4278 template<typename V> void encode(V& v) const
4286 tAListforQMC.clear();
4287 iE_Extensions.clear();
4291 tAListforQMC_t tAListforQMC;
4292 iE_Extensions_t iE_Extensions;
4296 TAIListforQMC ::= SEQUENCE (SIZE(1..maxnoofTAforQMC)) OF TAI-Item
4299 struct TAIListforQMC_elm : TAI_Item
4301 static constexpr const char* name() {return "TAIListforQMC_elm";}
4302 using parent_t = TAI_Item;
4305 struct TAIListforQMC : asn::sequenceof<TAIListforQMC_elm>
4307 static constexpr const char* name() {return "TAIListforQMC";}
4308 using parent_t = asn::sequenceof<TAIListforQMC_elm>;
4309 using constraint_t = asn::constraints<false,asn::span<1, maxnoofTAforQMC >>;
4313 TAIBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4318 struct TAIBasedQMC_ExtIEs
4320 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4322 size_t get_index() const {return type;}
4323 bool is_unknown() const { return type == 1; }
4324 void clear() {type = 0;}
4325 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4326 template<typename V> bool decode(V& v)
4329 if(!v(ref_nested())) return false;
4330 { type = 1; return true;}
4334 template<typename V> bool encode(V& v) const
4336 return v(ref_nested());
4340 template<typename V> bool decode(size_t index, V& v)
4345 case 1: type = 1; return v(ref_nested());
4346 ref_nested().clear();
4351 template<typename V> bool encode(size_t index, V& v) const
4353 if(index != type) {return false;} return v(ref_nested());
4360 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4362 size_t get_index() const {return type;}
4363 bool is_unknown() const { return type == 1; }
4364 void clear() {type = 0;}
4365 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4366 template<typename V> bool decode(V& v)
4369 if(!v(ref_nested())) return false;
4370 { type = 1; return true;}
4374 template<typename V> bool encode(V& v) const
4376 return v(ref_nested());
4380 template<typename V> bool decode(size_t index, V& v)
4385 case 1: type = 1; return v(ref_nested());
4386 ref_nested().clear();
4391 template<typename V> bool encode(size_t index, V& v) const
4393 if(index != type) {return false;} return v(ref_nested());
4400 struct Extension_t : asn::typefield<true>
4402 ~Extension_t() {clear();}
4403 size_t get_index() const {return type;}
4404 bool is_unknown() const { return type == 1; }
4407 type = 0; ref_nested().clear();
4409 template<typename V> static inline void enumerate(V& v)
4414 template<typename V> bool decode(size_t index, V& v)
4419 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4424 template<typename V> bool encode(size_t index, V& v) const
4426 if(index != type) return false;
4434 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
4436 size_t get_index() const {return type;}
4437 bool is_unknown() const { return type == 1; }
4438 void clear() {type = 0;}
4439 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
4440 template<typename V> bool decode(V& v)
4443 if(!v(ref_nested())) return false;
4444 { type = 1; return true;}
4448 template<typename V> bool encode(V& v) const
4450 return v(ref_nested());
4454 template<typename V> bool decode(size_t index, V& v)
4459 case 1: type = 1; return v(ref_nested());
4460 ref_nested().clear();
4465 template<typename V> bool encode(size_t index, V& v) const
4467 if(index != type) {return false;} return v(ref_nested());
4477 TAIBasedQMC ::= SEQUENCE {
4478 tAIListforQMC TAIListforQMC,
4479 iE-Extensions ProtocolExtensionContainer { {TAIBasedQMC-ExtIEs} } OPTIONAL,
4484 struct TAIBasedQMC : asn::sequence<2, 0, true, 1>
4486 static constexpr const char* name() {return "TAIBasedQMC";}
4487 using parent_t = asn::sequence<2, 0, true, 1>;
4488 struct tAIListforQMC_t : TAIListforQMC
4490 static constexpr const char* name() {return "tAIListforQMC_t";}
4491 using parent_t = TAIListforQMC;
4494 tAIListforQMC_t& ref_tAIListforQMC() {return tAIListforQMC;}
4495 tAIListforQMC_t const& ref_tAIListforQMC() const {return tAIListforQMC;}
4496 struct iE_Extensions_t : ProtocolExtensionContainer<TAIBasedQMC_ExtIEs>
4498 static constexpr const char* name() {return "iE_Extensions_t";}
4499 using parent_t = ProtocolExtensionContainer<TAIBasedQMC_ExtIEs>;
4500 static constexpr bool optional = true;
4503 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
4504 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
4505 template<typename V> void decode(V& v)
4511 template<typename V> void encode(V& v) const
4519 tAIListforQMC.clear();
4520 iE_Extensions.clear();
4524 tAIListforQMC_t tAIListforQMC;
4525 iE_Extensions_t iE_Extensions;
4529 PLMNListforQMC ::= SEQUENCE (SIZE(1..maxnoofPLMNforQMC)) OF PLMN-Identity
4532 struct PLMNListforQMC_elm : PLMN_Identity
4534 static constexpr const char* name() {return "PLMNListforQMC_elm";}
4535 using parent_t = PLMN_Identity;
4538 struct PLMNListforQMC : asn::sequenceof<PLMNListforQMC_elm>
4540 static constexpr const char* name() {return "PLMNListforQMC";}
4541 using parent_t = asn::sequenceof<PLMNListforQMC_elm>;
4542 using constraint_t = asn::constraints<false,asn::span<1, maxnoofPLMNforQMC >>;
4546 PLMNAreaBasedQMC-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4551 struct PLMNAreaBasedQMC_ExtIEs
4553 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4555 size_t get_index() const {return type;}
4556 bool is_unknown() const { return type == 1; }
4557 void clear() {type = 0;}
4558 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4559 template<typename V> bool decode(V& v)
4562 if(!v(ref_nested())) return false;
4563 { type = 1; return true;}
4567 template<typename V> bool encode(V& v) const
4569 return v(ref_nested());
4573 template<typename V> bool decode(size_t index, V& v)
4578 case 1: type = 1; return v(ref_nested());
4579 ref_nested().clear();
4584 template<typename V> bool encode(size_t index, V& v) const
4586 if(index != type) {return false;} return v(ref_nested());
4593 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4595 size_t get_index() const {return type;}
4596 bool is_unknown() const { return type == 1; }
4597 void clear() {type = 0;}
4598 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4599 template<typename V> bool decode(V& v)
4602 if(!v(ref_nested())) return false;
4603 { type = 1; return true;}
4607 template<typename V> bool encode(V& v) const
4609 return v(ref_nested());
4613 template<typename V> bool decode(size_t index, V& v)
4618 case 1: type = 1; return v(ref_nested());
4619 ref_nested().clear();
4624 template<typename V> bool encode(size_t index, V& v) const
4626 if(index != type) {return false;} return v(ref_nested());
4633 struct Extension_t : asn::typefield<true>
4635 ~Extension_t() {clear();}
4636 size_t get_index() const {return type;}
4637 bool is_unknown() const { return type == 1; }
4640 type = 0; ref_nested().clear();
4642 template<typename V> static inline void enumerate(V& v)
4647 template<typename V> bool decode(size_t index, V& v)
4652 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4657 template<typename V> bool encode(size_t index, V& v) const
4659 if(index != type) return false;
4667 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
4669 size_t get_index() const {return type;}
4670 bool is_unknown() const { return type == 1; }
4671 void clear() {type = 0;}
4672 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
4673 template<typename V> bool decode(V& v)
4676 if(!v(ref_nested())) return false;
4677 { type = 1; return true;}
4681 template<typename V> bool encode(V& v) const
4683 return v(ref_nested());
4687 template<typename V> bool decode(size_t index, V& v)
4692 case 1: type = 1; return v(ref_nested());
4693 ref_nested().clear();
4698 template<typename V> bool encode(size_t index, V& v) const
4700 if(index != type) {return false;} return v(ref_nested());
4710 PLMNAreaBasedQMC ::= SEQUENCE {
4711 plmnListforQMC PLMNListforQMC,
4712 iE-Extensions ProtocolExtensionContainer { {PLMNAreaBasedQMC-ExtIEs} } OPTIONAL,
4717 struct PLMNAreaBasedQMC : asn::sequence<2, 0, true, 1>
4719 static constexpr const char* name() {return "PLMNAreaBasedQMC";}
4720 using parent_t = asn::sequence<2, 0, true, 1>;
4721 struct plmnListforQMC_t : PLMNListforQMC
4723 static constexpr const char* name() {return "plmnListforQMC_t";}
4724 using parent_t = PLMNListforQMC;
4727 plmnListforQMC_t& ref_plmnListforQMC() {return plmnListforQMC;}
4728 plmnListforQMC_t const& ref_plmnListforQMC() const {return plmnListforQMC;}
4729 struct iE_Extensions_t : ProtocolExtensionContainer<PLMNAreaBasedQMC_ExtIEs>
4731 static constexpr const char* name() {return "iE_Extensions_t";}
4732 using parent_t = ProtocolExtensionContainer<PLMNAreaBasedQMC_ExtIEs>;
4733 static constexpr bool optional = true;
4736 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
4737 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
4738 template<typename V> void decode(V& v)
4744 template<typename V> void encode(V& v) const
4752 plmnListforQMC.clear();
4753 iE_Extensions.clear();
4757 plmnListforQMC_t plmnListforQMC;
4758 iE_Extensions_t iE_Extensions;
4762 AreaScopeOfQMC ::= CHOICE {
4763 cellBased CellBasedQMC,
4765 tAIBased TAIBasedQMC,
4766 pLMNAreaBased PLMNAreaBasedQMC,
4771 struct AreaScopeOfQMC : asn::choice<4, 0, true>
4773 static constexpr const char* name() {return "AreaScopeOfQMC";}
4774 using parent_t = asn::choice<4, 0, true>;
4775 index_type get_index() const {return index;}
4776 bool is_unknown() const {return index == 5;}
4777 void set_unknown() { set_index(5); }
4778 ~AreaScopeOfQMC() {clear();}
4779 struct cellBased_t : CellBasedQMC
4781 static constexpr const char* name() {return "cellBased_t";}
4782 using parent_t = CellBasedQMC;
4785 struct tABased_t : TABasedQMC
4787 static constexpr const char* name() {return "tABased_t";}
4788 using parent_t = TABasedQMC;
4791 struct tAIBased_t : TAIBasedQMC
4793 static constexpr const char* name() {return "tAIBased_t";}
4794 using parent_t = TAIBasedQMC;
4797 struct pLMNAreaBased_t : PLMNAreaBasedQMC
4799 static constexpr const char* name() {return "pLMNAreaBased_t";}
4800 using parent_t = PLMNAreaBasedQMC;
4807 case 1: var.destroy<cellBased_t>(); break;
4808 case 2: var.destroy<tABased_t>(); break;
4809 case 3: var.destroy<tAIBased_t>(); break;
4810 case 4: var.destroy<pLMNAreaBased_t>(); break;
4815 template<typename V> bool decode(size_t idx, V& v)
4820 case 1: set_index(1); return v(var.build<cellBased_t>());
4821 case 2: set_index(2); return v(var.build<tABased_t>());
4822 case 3: set_index(3); return v(var.build<tAIBased_t>());
4823 case 4: set_index(4); return v(var.build<pLMNAreaBased_t>());
4828 template<typename V> bool encode(V& v) const
4832 case 1: return v(var.as<cellBased_t>());
4833 case 2: return v(var.as<tABased_t>());
4834 case 3: return v(var.as<tAIBased_t>());
4835 case 4: return v(var.as<pLMNAreaBased_t>());
4839 template<typename V> static inline void enumerate(V& v)
4841 v.template operator()<cellBased_t>(1);
4842 v.template operator()<tABased_t>(2);
4843 v.template operator()<tAIBased_t>(3);
4844 v.template operator()<pLMNAreaBased_t>(4);
4847 cellBased_t& select_cellBased() { if(get_index() != 1) { clear(); set_index(1); return var.build<cellBased_t>();} return var.as<cellBased_t>();}
4848 cellBased_t const* get_cellBased() const { if(get_index() == 1) { return &var.as<cellBased_t>();} return nullptr; }
4849 tABased_t& select_tABased() { if(get_index() != 2) { clear(); set_index(2); return var.build<tABased_t>();} return var.as<tABased_t>();}
4850 tABased_t const* get_tABased() const { if(get_index() == 2) { return &var.as<tABased_t>();} return nullptr; }
4851 tAIBased_t& select_tAIBased() { if(get_index() != 3) { clear(); set_index(3); return var.build<tAIBased_t>();} return var.as<tAIBased_t>();}
4852 tAIBased_t const* get_tAIBased() const { if(get_index() == 3) { return &var.as<tAIBased_t>();} return nullptr; }
4853 pLMNAreaBased_t& select_pLMNAreaBased() { if(get_index() != 4) { clear(); set_index(4); return var.build<pLMNAreaBased_t>();} return var.as<pLMNAreaBased_t>();}
4854 pLMNAreaBased_t const* get_pLMNAreaBased() const { if(get_index() == 4) { return &var.as<pLMNAreaBased_t>();} return nullptr; }
4856 void set_index(index_type i) {index = i; base::set();}
4859 char dummy1[sizeof(cellBased_t)];
4860 char dummy2[sizeof(tABased_t)];
4861 char dummy3[sizeof(tAIBased_t)];
4862 char dummy4[sizeof(pLMNAreaBased_t)];
4865 asn::variant<sizeof(union_type)> var;
4866 index_type index {0};
4869 FreqBandIndicator ::= INTEGER (1..256, ...)
4872 struct FreqBandIndicator : asn::integer<>
4874 using constraint_t = asn::constraints<true,asn::span<1, 256>>;
4875 static constexpr const char* name() {return "FreqBandIndicator";}
4876 using parent_t = asn::integer<>;
4881 BandInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
4886 struct BandInfo_ExtIEs
4888 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
4890 size_t get_index() const {return type;}
4891 bool is_unknown() const { return type == 1; }
4892 void clear() {type = 0;}
4893 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
4894 template<typename V> bool decode(V& v)
4897 if(!v(ref_nested())) return false;
4898 { type = 1; return true;}
4902 template<typename V> bool encode(V& v) const
4904 return v(ref_nested());
4908 template<typename V> bool decode(size_t index, V& v)
4913 case 1: type = 1; return v(ref_nested());
4914 ref_nested().clear();
4919 template<typename V> bool encode(size_t index, V& v) const
4921 if(index != type) {return false;} return v(ref_nested());
4928 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
4930 size_t get_index() const {return type;}
4931 bool is_unknown() const { return type == 1; }
4932 void clear() {type = 0;}
4933 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
4934 template<typename V> bool decode(V& v)
4937 if(!v(ref_nested())) return false;
4938 { type = 1; return true;}
4942 template<typename V> bool encode(V& v) const
4944 return v(ref_nested());
4948 template<typename V> bool decode(size_t index, V& v)
4953 case 1: type = 1; return v(ref_nested());
4954 ref_nested().clear();
4959 template<typename V> bool encode(size_t index, V& v) const
4961 if(index != type) {return false;} return v(ref_nested());
4968 struct Extension_t : asn::typefield<true>
4970 ~Extension_t() {clear();}
4971 size_t get_index() const {return type;}
4972 bool is_unknown() const { return type == 1; }
4975 type = 0; ref_nested().clear();
4977 template<typename V> static inline void enumerate(V& v)
4982 template<typename V> bool decode(size_t index, V& v)
4987 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
4992 template<typename V> bool encode(size_t index, V& v) const
4994 if(index != type) return false;
5002 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5004 size_t get_index() const {return type;}
5005 bool is_unknown() const { return type == 1; }
5006 void clear() {type = 0;}
5007 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5008 template<typename V> bool decode(V& v)
5011 if(!v(ref_nested())) return false;
5012 { type = 1; return true;}
5016 template<typename V> bool encode(V& v) const
5018 return v(ref_nested());
5022 template<typename V> bool decode(size_t index, V& v)
5027 case 1: type = 1; return v(ref_nested());
5028 ref_nested().clear();
5033 template<typename V> bool encode(size_t index, V& v) const
5035 if(index != type) {return false;} return v(ref_nested());
5045 BandInfo ::= SEQUENCE {
5046 freqBandIndicator FreqBandIndicator,
5047 iE-Extensions ProtocolExtensionContainer { {BandInfo-ExtIEs} } OPTIONAL,
5052 struct BandInfo : asn::sequence<2, 0, true, 1>
5054 static constexpr const char* name() {return "BandInfo";}
5055 using parent_t = asn::sequence<2, 0, true, 1>;
5056 struct freqBandIndicator_t : FreqBandIndicator
5058 static constexpr const char* name() {return "freqBandIndicator_t";}
5059 using parent_t = FreqBandIndicator;
5062 freqBandIndicator_t& ref_freqBandIndicator() {return freqBandIndicator;}
5063 freqBandIndicator_t const& ref_freqBandIndicator() const {return freqBandIndicator;}
5064 struct iE_Extensions_t : ProtocolExtensionContainer<BandInfo_ExtIEs>
5066 static constexpr const char* name() {return "iE_Extensions_t";}
5067 using parent_t = ProtocolExtensionContainer<BandInfo_ExtIEs>;
5068 static constexpr bool optional = true;
5071 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5072 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5073 template<typename V> void decode(V& v)
5075 v(freqBandIndicator);
5079 template<typename V> void encode(V& v) const
5081 v(freqBandIndicator);
5087 freqBandIndicator.clear();
5088 iE_Extensions.clear();
5092 freqBandIndicator_t freqBandIndicator;
5093 iE_Extensions_t iE_Extensions;
5097 BandwidthReducedSI::= ENUMERATED {
5103 struct BandwidthReducedSI : asn::enumerated<1, 0, true>
5105 static constexpr const char* name() {return "BandwidthReducedSI";}
5106 using parent_t = asn::enumerated<1, 0, true>;
5114 BearerType ::= ENUMERATED {
5120 struct BearerType : asn::enumerated<1, 0, true>
5122 static constexpr const char* name() {return "BearerType";}
5123 using parent_t = asn::enumerated<1, 0, true>;
5131 BenefitMetric ::= INTEGER (-101..100, ...)
5134 struct BenefitMetric : asn::integer<>
5136 using constraint_t = asn::constraints<true,asn::span<-101, 100>>;
5137 static constexpr const char* name() {return "BenefitMetric";}
5138 using parent_t = asn::integer<>;
5143 BitRate ::= INTEGER (0..10000000000)
5146 struct BitRate : asn::integer<>
5148 using constraint_t = asn::constraints<false,asn::span<0, 10000000000>>;
5149 static constexpr const char* name() {return "BitRate";}
5150 using parent_t = asn::integer<>;
5155 BluetoothMeasConfig::= ENUMERATED {setup,...}
5158 struct BluetoothMeasConfig : asn::enumerated<1, 0, true>
5160 static constexpr const char* name() {return "BluetoothMeasConfig";}
5161 using parent_t = asn::enumerated<1, 0, true>;
5169 BluetoothName ::= OCTET STRING (SIZE (1..248))
5172 struct BluetoothName : asn::ostring<>
5174 using constraint_t = asn::constraints<false,asn::span<1, 248>>;
5175 static constexpr const char* name() {return "BluetoothName";}
5176 using parent_t = asn::ostring<>;
5181 BluetoothMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofBluetoothName)) OF BluetoothName
5184 struct BluetoothMeasConfigNameList_elm : BluetoothName
5186 static constexpr const char* name() {return "BluetoothMeasConfigNameList_elm";}
5187 using parent_t = BluetoothName;
5190 struct BluetoothMeasConfigNameList : asn::sequenceof<BluetoothMeasConfigNameList_elm>
5192 static constexpr const char* name() {return "BluetoothMeasConfigNameList";}
5193 using parent_t = asn::sequenceof<BluetoothMeasConfigNameList_elm>;
5194 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBluetoothName >>;
5198 BluetoothMeasurementConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5203 struct BluetoothMeasurementConfiguration_ExtIEs
5205 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5207 size_t get_index() const {return type;}
5208 bool is_unknown() const { return type == 1; }
5209 void clear() {type = 0;}
5210 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
5211 template<typename V> bool decode(V& v)
5214 if(!v(ref_nested())) return false;
5215 { type = 1; return true;}
5219 template<typename V> bool encode(V& v) const
5221 return v(ref_nested());
5225 template<typename V> bool decode(size_t index, V& v)
5230 case 1: type = 1; return v(ref_nested());
5231 ref_nested().clear();
5236 template<typename V> bool encode(size_t index, V& v) const
5238 if(index != type) {return false;} return v(ref_nested());
5245 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
5247 size_t get_index() const {return type;}
5248 bool is_unknown() const { return type == 1; }
5249 void clear() {type = 0;}
5250 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
5251 template<typename V> bool decode(V& v)
5254 if(!v(ref_nested())) return false;
5255 { type = 1; return true;}
5259 template<typename V> bool encode(V& v) const
5261 return v(ref_nested());
5265 template<typename V> bool decode(size_t index, V& v)
5270 case 1: type = 1; return v(ref_nested());
5271 ref_nested().clear();
5276 template<typename V> bool encode(size_t index, V& v) const
5278 if(index != type) {return false;} return v(ref_nested());
5285 struct Extension_t : asn::typefield<true>
5287 ~Extension_t() {clear();}
5288 size_t get_index() const {return type;}
5289 bool is_unknown() const { return type == 1; }
5292 type = 0; ref_nested().clear();
5294 template<typename V> static inline void enumerate(V& v)
5299 template<typename V> bool decode(size_t index, V& v)
5304 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
5309 template<typename V> bool encode(size_t index, V& v) const
5311 if(index != type) return false;
5319 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5321 size_t get_index() const {return type;}
5322 bool is_unknown() const { return type == 1; }
5323 void clear() {type = 0;}
5324 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5325 template<typename V> bool decode(V& v)
5328 if(!v(ref_nested())) return false;
5329 { type = 1; return true;}
5333 template<typename V> bool encode(V& v) const
5335 return v(ref_nested());
5339 template<typename V> bool decode(size_t index, V& v)
5344 case 1: type = 1; return v(ref_nested());
5345 ref_nested().clear();
5350 template<typename V> bool encode(size_t index, V& v) const
5352 if(index != type) {return false;} return v(ref_nested());
5362 BluetoothMeasurementConfiguration ::= SEQUENCE {
5363 bluetoothMeasConfig BluetoothMeasConfig,
5364 bluetoothMeasConfigNameList BluetoothMeasConfigNameList OPTIONAL,
5365 bt-rssi ENUMERATED {true, ...} OPTIONAL,
5366 iE-Extensions ProtocolExtensionContainer { {BluetoothMeasurementConfiguration-ExtIEs} } OPTIONAL,
5371 struct BluetoothMeasurementConfiguration : asn::sequence<4, 0, true, 3>
5373 static constexpr const char* name() {return "BluetoothMeasurementConfiguration";}
5374 using parent_t = asn::sequence<4, 0, true, 3>;
5375 struct bluetoothMeasConfig_t : BluetoothMeasConfig
5377 static constexpr const char* name() {return "bluetoothMeasConfig_t";}
5378 using parent_t = BluetoothMeasConfig;
5381 bluetoothMeasConfig_t& ref_bluetoothMeasConfig() {return bluetoothMeasConfig;}
5382 bluetoothMeasConfig_t const& ref_bluetoothMeasConfig() const {return bluetoothMeasConfig;}
5383 struct bluetoothMeasConfigNameList_t : BluetoothMeasConfigNameList
5385 static constexpr const char* name() {return "bluetoothMeasConfigNameList_t";}
5386 using parent_t = BluetoothMeasConfigNameList;
5387 static constexpr bool optional = true;
5390 bluetoothMeasConfigNameList_t& set_bluetoothMeasConfigNameList() { bluetoothMeasConfigNameList.setpresent(true); return bluetoothMeasConfigNameList;}
5391 bluetoothMeasConfigNameList_t const* get_bluetoothMeasConfigNameList() const {return bluetoothMeasConfigNameList.is_valid() ? &bluetoothMeasConfigNameList : nullptr;}
5392 struct bt_rssi_t : asn::enumerated<1, 0, true>
5394 static constexpr const char* name() {return "bt_rssi_t";}
5395 using parent_t = asn::enumerated<1, 0, true>;
5396 static constexpr bool optional = true;
5403 bt_rssi_t& set_bt_rssi() { bt_rssi.setpresent(true); return bt_rssi;}
5404 bt_rssi_t const* get_bt_rssi() const {return bt_rssi.is_valid() ? &bt_rssi : nullptr;}
5405 struct iE_Extensions_t : ProtocolExtensionContainer<BluetoothMeasurementConfiguration_ExtIEs>
5407 static constexpr const char* name() {return "iE_Extensions_t";}
5408 using parent_t = ProtocolExtensionContainer<BluetoothMeasurementConfiguration_ExtIEs>;
5409 static constexpr bool optional = true;
5412 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5413 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5414 template<typename V> void decode(V& v)
5416 v(bluetoothMeasConfig);
5417 v(bluetoothMeasConfigNameList);
5422 template<typename V> void encode(V& v) const
5424 v(bluetoothMeasConfig);
5425 v(bluetoothMeasConfigNameList);
5432 bluetoothMeasConfig.clear();
5433 bluetoothMeasConfigNameList.clear();
5435 iE_Extensions.clear();
5439 bluetoothMeasConfig_t bluetoothMeasConfig;
5440 bluetoothMeasConfigNameList_t bluetoothMeasConfigNameList;
5442 iE_Extensions_t iE_Extensions;
5446 BroadcastPLMNs-Item ::= SEQUENCE (SIZE(1..maxnoofBPLMNs)) OF PLMN-Identity
5449 struct BroadcastPLMNs_Item_elm : PLMN_Identity
5451 static constexpr const char* name() {return "BroadcastPLMNs_Item_elm";}
5452 using parent_t = PLMN_Identity;
5455 struct BroadcastPLMNs_Item : asn::sequenceof<BroadcastPLMNs_Item_elm>
5457 static constexpr const char* name() {return "BroadcastPLMNs-Item";}
5458 using parent_t = asn::sequenceof<BroadcastPLMNs_Item_elm>;
5459 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBPLMNs >>;
5463 CNTypeRestrictionsItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5468 struct CNTypeRestrictionsItem_ExtIEs
5470 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5472 size_t get_index() const {return type;}
5473 bool is_unknown() const { return type == 1; }
5474 void clear() {type = 0;}
5475 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
5476 template<typename V> bool decode(V& v)
5479 if(!v(ref_nested())) return false;
5480 { type = 1; return true;}
5484 template<typename V> bool encode(V& v) const
5486 return v(ref_nested());
5490 template<typename V> bool decode(size_t index, V& v)
5495 case 1: type = 1; return v(ref_nested());
5496 ref_nested().clear();
5501 template<typename V> bool encode(size_t index, V& v) const
5503 if(index != type) {return false;} return v(ref_nested());
5510 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
5512 size_t get_index() const {return type;}
5513 bool is_unknown() const { return type == 1; }
5514 void clear() {type = 0;}
5515 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
5516 template<typename V> bool decode(V& v)
5519 if(!v(ref_nested())) return false;
5520 { type = 1; return true;}
5524 template<typename V> bool encode(V& v) const
5526 return v(ref_nested());
5530 template<typename V> bool decode(size_t index, V& v)
5535 case 1: type = 1; return v(ref_nested());
5536 ref_nested().clear();
5541 template<typename V> bool encode(size_t index, V& v) const
5543 if(index != type) {return false;} return v(ref_nested());
5550 struct Extension_t : asn::typefield<true>
5552 ~Extension_t() {clear();}
5553 size_t get_index() const {return type;}
5554 bool is_unknown() const { return type == 1; }
5557 type = 0; ref_nested().clear();
5559 template<typename V> static inline void enumerate(V& v)
5564 template<typename V> bool decode(size_t index, V& v)
5569 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
5574 template<typename V> bool encode(size_t index, V& v) const
5576 if(index != type) return false;
5584 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5586 size_t get_index() const {return type;}
5587 bool is_unknown() const { return type == 1; }
5588 void clear() {type = 0;}
5589 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5590 template<typename V> bool decode(V& v)
5593 if(!v(ref_nested())) return false;
5594 { type = 1; return true;}
5598 template<typename V> bool encode(V& v) const
5600 return v(ref_nested());
5604 template<typename V> bool decode(size_t index, V& v)
5609 case 1: type = 1; return v(ref_nested());
5610 ref_nested().clear();
5615 template<typename V> bool encode(size_t index, V& v) const
5617 if(index != type) {return false;} return v(ref_nested());
5627 CNTypeRestrictionsItem ::= SEQUENCE {
5628 plmn-Id PLMN-Identity,
5629 cn-type ENUMERATED {fiveGC-forbidden, ...},
5630 iE-Extensions ProtocolExtensionContainer { {CNTypeRestrictionsItem-ExtIEs} } OPTIONAL,
5635 struct CNTypeRestrictionsItem : asn::sequence<3, 0, true, 1>
5637 static constexpr const char* name() {return "CNTypeRestrictionsItem";}
5638 using parent_t = asn::sequence<3, 0, true, 1>;
5639 struct plmn_Id_t : PLMN_Identity
5641 static constexpr const char* name() {return "plmn_Id_t";}
5642 using parent_t = PLMN_Identity;
5645 plmn_Id_t& ref_plmn_Id() {return plmn_Id;}
5646 plmn_Id_t const& ref_plmn_Id() const {return plmn_Id;}
5647 struct cn_type_t : asn::enumerated<1, 0, true>
5649 static constexpr const char* name() {return "cn_type_t";}
5650 using parent_t = asn::enumerated<1, 0, true>;
5657 cn_type_t& ref_cn_type() {return cn_type;}
5658 cn_type_t const& ref_cn_type() const {return cn_type;}
5659 struct iE_Extensions_t : ProtocolExtensionContainer<CNTypeRestrictionsItem_ExtIEs>
5661 static constexpr const char* name() {return "iE_Extensions_t";}
5662 using parent_t = ProtocolExtensionContainer<CNTypeRestrictionsItem_ExtIEs>;
5663 static constexpr bool optional = true;
5666 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5667 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5668 template<typename V> void decode(V& v)
5675 template<typename V> void encode(V& v) const
5686 iE_Extensions.clear();
5692 iE_Extensions_t iE_Extensions;
5696 CNTypeRestrictions ::= SEQUENCE (SIZE(1.. maxnoofEPLMNsPlusOne)) OF CNTypeRestrictionsItem
5699 struct CNTypeRestrictions_elm : CNTypeRestrictionsItem
5701 static constexpr const char* name() {return "CNTypeRestrictions_elm";}
5702 using parent_t = CNTypeRestrictionsItem;
5705 struct CNTypeRestrictions : asn::sequenceof<CNTypeRestrictions_elm>
5707 static constexpr const char* name() {return "CNTypeRestrictions";}
5708 using parent_t = asn::sequenceof<CNTypeRestrictions_elm>;
5709 using constraint_t = asn::constraints<false,asn::span<1, maxnoofEPLMNsPlusOne >>;
5713 PDCP-SNExtended ::= INTEGER (0..32767)
5716 struct PDCP_SNExtended : asn::integer<>
5718 using constraint_t = asn::constraints<false,asn::span<0, 32767>>;
5719 static constexpr const char* name() {return "PDCP-SNExtended";}
5720 using parent_t = asn::integer<>;
5725 HFNModified ::= INTEGER (0..131071)
5728 struct HFNModified : asn::integer<>
5730 using constraint_t = asn::constraints<false,asn::span<0, 131071>>;
5731 static constexpr const char* name() {return "HFNModified";}
5732 using parent_t = asn::integer<>;
5737 COUNTValueExtended-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5742 struct COUNTValueExtended_ExtIEs
5744 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5746 size_t get_index() const {return type;}
5747 bool is_unknown() const { return type == 1; }
5748 void clear() {type = 0;}
5749 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
5750 template<typename V> bool decode(V& v)
5753 if(!v(ref_nested())) return false;
5754 { type = 1; return true;}
5758 template<typename V> bool encode(V& v) const
5760 return v(ref_nested());
5764 template<typename V> bool decode(size_t index, V& v)
5769 case 1: type = 1; return v(ref_nested());
5770 ref_nested().clear();
5775 template<typename V> bool encode(size_t index, V& v) const
5777 if(index != type) {return false;} return v(ref_nested());
5784 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
5786 size_t get_index() const {return type;}
5787 bool is_unknown() const { return type == 1; }
5788 void clear() {type = 0;}
5789 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
5790 template<typename V> bool decode(V& v)
5793 if(!v(ref_nested())) return false;
5794 { type = 1; return true;}
5798 template<typename V> bool encode(V& v) const
5800 return v(ref_nested());
5804 template<typename V> bool decode(size_t index, V& v)
5809 case 1: type = 1; return v(ref_nested());
5810 ref_nested().clear();
5815 template<typename V> bool encode(size_t index, V& v) const
5817 if(index != type) {return false;} return v(ref_nested());
5824 struct Extension_t : asn::typefield<true>
5826 ~Extension_t() {clear();}
5827 size_t get_index() const {return type;}
5828 bool is_unknown() const { return type == 1; }
5831 type = 0; ref_nested().clear();
5833 template<typename V> static inline void enumerate(V& v)
5838 template<typename V> bool decode(size_t index, V& v)
5843 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
5848 template<typename V> bool encode(size_t index, V& v) const
5850 if(index != type) return false;
5858 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
5860 size_t get_index() const {return type;}
5861 bool is_unknown() const { return type == 1; }
5862 void clear() {type = 0;}
5863 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
5864 template<typename V> bool decode(V& v)
5867 if(!v(ref_nested())) return false;
5868 { type = 1; return true;}
5872 template<typename V> bool encode(V& v) const
5874 return v(ref_nested());
5878 template<typename V> bool decode(size_t index, V& v)
5883 case 1: type = 1; return v(ref_nested());
5884 ref_nested().clear();
5889 template<typename V> bool encode(size_t index, V& v) const
5891 if(index != type) {return false;} return v(ref_nested());
5901 COUNTValueExtended ::= SEQUENCE {
5902 pDCP-SNExtended PDCP-SNExtended,
5903 hFNModified HFNModified,
5904 iE-Extensions ProtocolExtensionContainer { {COUNTValueExtended-ExtIEs} } OPTIONAL,
5909 struct COUNTValueExtended : asn::sequence<3, 0, true, 1>
5911 static constexpr const char* name() {return "COUNTValueExtended";}
5912 using parent_t = asn::sequence<3, 0, true, 1>;
5913 struct pDCP_SNExtended_t : PDCP_SNExtended
5915 static constexpr const char* name() {return "pDCP_SNExtended_t";}
5916 using parent_t = PDCP_SNExtended;
5919 pDCP_SNExtended_t& ref_pDCP_SNExtended() {return pDCP_SNExtended;}
5920 pDCP_SNExtended_t const& ref_pDCP_SNExtended() const {return pDCP_SNExtended;}
5921 struct hFNModified_t : HFNModified
5923 static constexpr const char* name() {return "hFNModified_t";}
5924 using parent_t = HFNModified;
5927 hFNModified_t& ref_hFNModified() {return hFNModified;}
5928 hFNModified_t const& ref_hFNModified() const {return hFNModified;}
5929 struct iE_Extensions_t : ProtocolExtensionContainer<COUNTValueExtended_ExtIEs>
5931 static constexpr const char* name() {return "iE_Extensions_t";}
5932 using parent_t = ProtocolExtensionContainer<COUNTValueExtended_ExtIEs>;
5933 static constexpr bool optional = true;
5936 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
5937 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
5938 template<typename V> void decode(V& v)
5945 template<typename V> void encode(V& v) const
5954 pDCP_SNExtended.clear();
5955 hFNModified.clear();
5956 iE_Extensions.clear();
5960 pDCP_SNExtended_t pDCP_SNExtended;
5961 hFNModified_t hFNModified;
5962 iE_Extensions_t iE_Extensions;
5966 PDCP-SN ::= INTEGER (0..4095)
5969 struct PDCP_SN : asn::integer<>
5971 using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
5972 static constexpr const char* name() {return "PDCP-SN";}
5973 using parent_t = asn::integer<>;
5978 HFN ::= INTEGER (0..1048575)
5981 struct HFN : asn::integer<>
5983 using constraint_t = asn::constraints<false,asn::span<0, 1048575>>;
5984 static constexpr const char* name() {return "HFN";}
5985 using parent_t = asn::integer<>;
5990 COUNTvalue-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
5995 struct COUNTvalue_ExtIEs
5997 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
5999 size_t get_index() const {return type;}
6000 bool is_unknown() const { return type == 1; }
6001 void clear() {type = 0;}
6002 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6003 template<typename V> bool decode(V& v)
6006 if(!v(ref_nested())) return false;
6007 { type = 1; return true;}
6011 template<typename V> bool encode(V& v) const
6013 return v(ref_nested());
6017 template<typename V> bool decode(size_t index, V& v)
6022 case 1: type = 1; return v(ref_nested());
6023 ref_nested().clear();
6028 template<typename V> bool encode(size_t index, V& v) const
6030 if(index != type) {return false;} return v(ref_nested());
6037 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6039 size_t get_index() const {return type;}
6040 bool is_unknown() const { return type == 1; }
6041 void clear() {type = 0;}
6042 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6043 template<typename V> bool decode(V& v)
6046 if(!v(ref_nested())) return false;
6047 { type = 1; return true;}
6051 template<typename V> bool encode(V& v) const
6053 return v(ref_nested());
6057 template<typename V> bool decode(size_t index, V& v)
6062 case 1: type = 1; return v(ref_nested());
6063 ref_nested().clear();
6068 template<typename V> bool encode(size_t index, V& v) const
6070 if(index != type) {return false;} return v(ref_nested());
6077 struct Extension_t : asn::typefield<true>
6079 ~Extension_t() {clear();}
6080 size_t get_index() const {return type;}
6081 bool is_unknown() const { return type == 1; }
6084 type = 0; ref_nested().clear();
6086 template<typename V> static inline void enumerate(V& v)
6091 template<typename V> bool decode(size_t index, V& v)
6096 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
6101 template<typename V> bool encode(size_t index, V& v) const
6103 if(index != type) return false;
6111 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
6113 size_t get_index() const {return type;}
6114 bool is_unknown() const { return type == 1; }
6115 void clear() {type = 0;}
6116 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
6117 template<typename V> bool decode(V& v)
6120 if(!v(ref_nested())) return false;
6121 { type = 1; return true;}
6125 template<typename V> bool encode(V& v) const
6127 return v(ref_nested());
6131 template<typename V> bool decode(size_t index, V& v)
6136 case 1: type = 1; return v(ref_nested());
6137 ref_nested().clear();
6142 template<typename V> bool encode(size_t index, V& v) const
6144 if(index != type) {return false;} return v(ref_nested());
6154 COUNTvalue ::= SEQUENCE {
6157 iE-Extensions ProtocolExtensionContainer { {COUNTvalue-ExtIEs} } OPTIONAL,
6162 struct COUNTvalue : asn::sequence<3, 0, true, 1>
6164 static constexpr const char* name() {return "COUNTvalue";}
6165 using parent_t = asn::sequence<3, 0, true, 1>;
6166 struct pDCP_SN_t : PDCP_SN
6168 static constexpr const char* name() {return "pDCP_SN_t";}
6169 using parent_t = PDCP_SN;
6172 pDCP_SN_t& ref_pDCP_SN() {return pDCP_SN;}
6173 pDCP_SN_t const& ref_pDCP_SN() const {return pDCP_SN;}
6176 static constexpr const char* name() {return "hFN_t";}
6177 using parent_t = HFN;
6180 hFN_t& ref_hFN() {return hFN;}
6181 hFN_t const& ref_hFN() const {return hFN;}
6182 struct iE_Extensions_t : ProtocolExtensionContainer<COUNTvalue_ExtIEs>
6184 static constexpr const char* name() {return "iE_Extensions_t";}
6185 using parent_t = ProtocolExtensionContainer<COUNTvalue_ExtIEs>;
6186 static constexpr bool optional = true;
6189 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
6190 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
6191 template<typename V> void decode(V& v)
6198 template<typename V> void encode(V& v) const
6209 iE_Extensions.clear();
6215 iE_Extensions_t iE_Extensions;
6219 PDCP-SNlength18 ::= INTEGER (0..262143)
6222 struct PDCP_SNlength18 : asn::integer<>
6224 using constraint_t = asn::constraints<false,asn::span<0, 262143>>;
6225 static constexpr const char* name() {return "PDCP-SNlength18";}
6226 using parent_t = asn::integer<>;
6231 HFNforPDCP-SNlength18 ::= INTEGER (0..16383)
6234 struct HFNforPDCP_SNlength18 : asn::integer<>
6236 using constraint_t = asn::constraints<false,asn::span<0, 16383>>;
6237 static constexpr const char* name() {return "HFNforPDCP-SNlength18";}
6238 using parent_t = asn::integer<>;
6243 COUNTvaluePDCP-SNlength18-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
6248 struct COUNTvaluePDCP_SNlength18_ExtIEs
6250 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
6252 size_t get_index() const {return type;}
6253 bool is_unknown() const { return type == 1; }
6254 void clear() {type = 0;}
6255 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6256 template<typename V> bool decode(V& v)
6259 if(!v(ref_nested())) return false;
6260 { type = 1; return true;}
6264 template<typename V> bool encode(V& v) const
6266 return v(ref_nested());
6270 template<typename V> bool decode(size_t index, V& v)
6275 case 1: type = 1; return v(ref_nested());
6276 ref_nested().clear();
6281 template<typename V> bool encode(size_t index, V& v) const
6283 if(index != type) {return false;} return v(ref_nested());
6290 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6292 size_t get_index() const {return type;}
6293 bool is_unknown() const { return type == 1; }
6294 void clear() {type = 0;}
6295 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6296 template<typename V> bool decode(V& v)
6299 if(!v(ref_nested())) return false;
6300 { type = 1; return true;}
6304 template<typename V> bool encode(V& v) const
6306 return v(ref_nested());
6310 template<typename V> bool decode(size_t index, V& v)
6315 case 1: type = 1; return v(ref_nested());
6316 ref_nested().clear();
6321 template<typename V> bool encode(size_t index, V& v) const
6323 if(index != type) {return false;} return v(ref_nested());
6330 struct Extension_t : asn::typefield<true>
6332 ~Extension_t() {clear();}
6333 size_t get_index() const {return type;}
6334 bool is_unknown() const { return type == 1; }
6337 type = 0; ref_nested().clear();
6339 template<typename V> static inline void enumerate(V& v)
6344 template<typename V> bool decode(size_t index, V& v)
6349 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
6354 template<typename V> bool encode(size_t index, V& v) const
6356 if(index != type) return false;
6364 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
6366 size_t get_index() const {return type;}
6367 bool is_unknown() const { return type == 1; }
6368 void clear() {type = 0;}
6369 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
6370 template<typename V> bool decode(V& v)
6373 if(!v(ref_nested())) return false;
6374 { type = 1; return true;}
6378 template<typename V> bool encode(V& v) const
6380 return v(ref_nested());
6384 template<typename V> bool decode(size_t index, V& v)
6389 case 1: type = 1; return v(ref_nested());
6390 ref_nested().clear();
6395 template<typename V> bool encode(size_t index, V& v) const
6397 if(index != type) {return false;} return v(ref_nested());
6407 COUNTvaluePDCP-SNlength18 ::= SEQUENCE {
6408 pDCP-SNlength18 PDCP-SNlength18,
6409 hFNforPDCP-SNlength18 HFNforPDCP-SNlength18,
6410 iE-Extensions ProtocolExtensionContainer { {COUNTvaluePDCP-SNlength18-ExtIEs} } OPTIONAL,
6415 struct COUNTvaluePDCP_SNlength18 : asn::sequence<3, 0, true, 1>
6417 static constexpr const char* name() {return "COUNTvaluePDCP-SNlength18";}
6418 using parent_t = asn::sequence<3, 0, true, 1>;
6419 struct pDCP_SNlength18_t : PDCP_SNlength18
6421 static constexpr const char* name() {return "pDCP_SNlength18_t";}
6422 using parent_t = PDCP_SNlength18;
6425 pDCP_SNlength18_t& ref_pDCP_SNlength18() {return pDCP_SNlength18;}
6426 pDCP_SNlength18_t const& ref_pDCP_SNlength18() const {return pDCP_SNlength18;}
6427 struct hFNforPDCP_SNlength18_t : HFNforPDCP_SNlength18
6429 static constexpr const char* name() {return "hFNforPDCP_SNlength18_t";}
6430 using parent_t = HFNforPDCP_SNlength18;
6433 hFNforPDCP_SNlength18_t& ref_hFNforPDCP_SNlength18() {return hFNforPDCP_SNlength18;}
6434 hFNforPDCP_SNlength18_t const& ref_hFNforPDCP_SNlength18() const {return hFNforPDCP_SNlength18;}
6435 struct iE_Extensions_t : ProtocolExtensionContainer<COUNTvaluePDCP_SNlength18_ExtIEs>
6437 static constexpr const char* name() {return "iE_Extensions_t";}
6438 using parent_t = ProtocolExtensionContainer<COUNTvaluePDCP_SNlength18_ExtIEs>;
6439 static constexpr bool optional = true;
6442 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
6443 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
6444 template<typename V> void decode(V& v)
6447 v(hFNforPDCP_SNlength18);
6451 template<typename V> void encode(V& v) const
6454 v(hFNforPDCP_SNlength18);
6460 pDCP_SNlength18.clear();
6461 hFNforPDCP_SNlength18.clear();
6462 iE_Extensions.clear();
6466 pDCP_SNlength18_t pDCP_SNlength18;
6467 hFNforPDCP_SNlength18_t hFNforPDCP_SNlength18;
6468 iE_Extensions_t iE_Extensions;
6472 CRNTI ::= BIT STRING (SIZE (16))
6475 struct CRNTI : asn::bstring<>
6477 using constraint_t = asn::constraints<false,asn::one<16>>;
6478 static constexpr const char* name() {return "CRNTI";}
6479 using parent_t = asn::bstring<>;
6484 CSG-Id ::= BIT STRING (SIZE (27))
6487 struct CSG_Id : asn::bstring<>
6489 using constraint_t = asn::constraints<false,asn::one<27>>;
6490 static constexpr const char* name() {return "CSG-Id";}
6491 using parent_t = asn::bstring<>;
6496 CSGMembershipStatus ::= ENUMERATED {
6502 struct CSGMembershipStatus : asn::enumerated<2, 0, false>
6504 static constexpr const char* name() {return "CSGMembershipStatus";}
6505 using parent_t = asn::enumerated<2, 0, false>;
6514 UEID ::= BIT STRING (SIZE (16))
6517 struct UEID : asn::bstring<>
6519 using constraint_t = asn::constraints<false,asn::one<16>>;
6520 static constexpr const char* name() {return "UEID";}
6521 using parent_t = asn::bstring<>;
6526 WidebandCQICodeword1::= CHOICE {
6527 four-bitCQI INTEGER (0..15, ...),
6528 three-bitSpatialDifferentialCQI INTEGER (0..7, ...),
6533 struct WidebandCQICodeword1 : asn::choice<2, 0, true>
6535 static constexpr const char* name() {return "WidebandCQICodeword1";}
6536 using parent_t = asn::choice<2, 0, true>;
6537 index_type get_index() const {return index;}
6538 bool is_unknown() const {return index == 3;}
6539 void set_unknown() { set_index(3); }
6540 ~WidebandCQICodeword1() {clear();}
6541 struct four_bitCQI_t : asn::integer<>
6543 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
6544 static constexpr const char* name() {return "four_bitCQI_t";}
6545 using parent_t = asn::integer<>;
6549 struct three_bitSpatialDifferentialCQI_t : asn::integer<>
6551 using constraint_t = asn::constraints<true,asn::span<0, 7>>;
6552 static constexpr const char* name() {return "three_bitSpatialDifferentialCQI_t";}
6553 using parent_t = asn::integer<>;
6561 case 1: var.destroy<four_bitCQI_t>(); break;
6562 case 2: var.destroy<three_bitSpatialDifferentialCQI_t>(); break;
6567 template<typename V> bool decode(size_t idx, V& v)
6572 case 1: set_index(1); return v(var.build<four_bitCQI_t>());
6573 case 2: set_index(2); return v(var.build<three_bitSpatialDifferentialCQI_t>());
6578 template<typename V> bool encode(V& v) const
6582 case 1: return v(var.as<four_bitCQI_t>());
6583 case 2: return v(var.as<three_bitSpatialDifferentialCQI_t>());
6587 template<typename V> static inline void enumerate(V& v)
6589 v.template operator()<four_bitCQI_t>(1);
6590 v.template operator()<three_bitSpatialDifferentialCQI_t>(2);
6593 four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
6594 four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
6595 three_bitSpatialDifferentialCQI_t& select_three_bitSpatialDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<three_bitSpatialDifferentialCQI_t>();} return var.as<three_bitSpatialDifferentialCQI_t>();}
6596 three_bitSpatialDifferentialCQI_t const* get_three_bitSpatialDifferentialCQI() const { if(get_index() == 2) { return &var.as<three_bitSpatialDifferentialCQI_t>();} return nullptr; }
6598 void set_index(index_type i) {index = i; base::set();}
6601 char dummy1[sizeof(four_bitCQI_t)];
6602 char dummy2[sizeof(three_bitSpatialDifferentialCQI_t)];
6605 asn::variant<sizeof(union_type)> var;
6606 index_type index {0};
6609 WidebandCQI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
6614 struct WidebandCQI_ExtIEs
6616 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
6618 size_t get_index() const {return type;}
6619 bool is_unknown() const { return type == 1; }
6620 void clear() {type = 0;}
6621 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
6622 template<typename V> bool decode(V& v)
6625 if(!v(ref_nested())) return false;
6626 { type = 1; return true;}
6630 template<typename V> bool encode(V& v) const
6632 return v(ref_nested());
6636 template<typename V> bool decode(size_t index, V& v)
6641 case 1: type = 1; return v(ref_nested());
6642 ref_nested().clear();
6647 template<typename V> bool encode(size_t index, V& v) const
6649 if(index != type) {return false;} return v(ref_nested());
6656 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
6658 size_t get_index() const {return type;}
6659 bool is_unknown() const { return type == 1; }
6660 void clear() {type = 0;}
6661 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
6662 template<typename V> bool decode(V& v)
6665 if(!v(ref_nested())) return false;
6666 { type = 1; return true;}
6670 template<typename V> bool encode(V& v) const
6672 return v(ref_nested());
6676 template<typename V> bool decode(size_t index, V& v)
6681 case 1: type = 1; return v(ref_nested());
6682 ref_nested().clear();
6687 template<typename V> bool encode(size_t index, V& v) const
6689 if(index != type) {return false;} return v(ref_nested());
6696 struct Extension_t : asn::typefield<true>
6698 ~Extension_t() {clear();}
6699 size_t get_index() const {return type;}
6700 bool is_unknown() const { return type == 1; }
6703 type = 0; ref_nested().clear();
6705 template<typename V> static inline void enumerate(V& v)
6710 template<typename V> bool decode(size_t index, V& v)
6715 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
6720 template<typename V> bool encode(size_t index, V& v) const
6722 if(index != type) return false;
6730 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
6732 size_t get_index() const {return type;}
6733 bool is_unknown() const { return type == 1; }
6734 void clear() {type = 0;}
6735 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
6736 template<typename V> bool decode(V& v)
6739 if(!v(ref_nested())) return false;
6740 { type = 1; return true;}
6744 template<typename V> bool encode(V& v) const
6746 return v(ref_nested());
6750 template<typename V> bool decode(size_t index, V& v)
6755 case 1: type = 1; return v(ref_nested());
6756 ref_nested().clear();
6761 template<typename V> bool encode(size_t index, V& v) const
6763 if(index != type) {return false;} return v(ref_nested());
6773 WidebandCQI ::= SEQUENCE {
6774 widebandCQICodeword0 INTEGER (0..15, ...),
6775 widebandCQICodeword1 WidebandCQICodeword1 OPTIONAL,
6776 iE-Extensions ProtocolExtensionContainer { {WidebandCQI-ExtIEs} } OPTIONAL,
6781 struct WidebandCQI : asn::sequence<3, 0, true, 2>
6783 static constexpr const char* name() {return "WidebandCQI";}
6784 using parent_t = asn::sequence<3, 0, true, 2>;
6785 struct widebandCQICodeword0_t : asn::integer<>
6787 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
6788 static constexpr const char* name() {return "widebandCQICodeword0_t";}
6789 using parent_t = asn::integer<>;
6793 widebandCQICodeword0_t& ref_widebandCQICodeword0() {return widebandCQICodeword0;}
6794 widebandCQICodeword0_t const& ref_widebandCQICodeword0() const {return widebandCQICodeword0;}
6795 struct widebandCQICodeword1_t : WidebandCQICodeword1
6797 static constexpr const char* name() {return "widebandCQICodeword1_t";}
6798 using parent_t = WidebandCQICodeword1;
6799 static constexpr bool optional = true;
6802 widebandCQICodeword1_t& set_widebandCQICodeword1() { widebandCQICodeword1.setpresent(true); return widebandCQICodeword1;}
6803 widebandCQICodeword1_t const* get_widebandCQICodeword1() const {return widebandCQICodeword1.is_valid() ? &widebandCQICodeword1 : nullptr;}
6804 struct iE_Extensions_t : ProtocolExtensionContainer<WidebandCQI_ExtIEs>
6806 static constexpr const char* name() {return "iE_Extensions_t";}
6807 using parent_t = ProtocolExtensionContainer<WidebandCQI_ExtIEs>;
6808 static constexpr bool optional = true;
6811 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
6812 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
6813 template<typename V> void decode(V& v)
6815 v(widebandCQICodeword0);
6816 v(widebandCQICodeword1);
6820 template<typename V> void encode(V& v) const
6822 v(widebandCQICodeword0);
6823 v(widebandCQICodeword1);
6829 widebandCQICodeword0.clear();
6830 widebandCQICodeword1.clear();
6831 iE_Extensions.clear();
6835 widebandCQICodeword0_t widebandCQICodeword0;
6836 widebandCQICodeword1_t widebandCQICodeword1;
6837 iE_Extensions_t iE_Extensions;
6841 SubbandSize ::= ENUMERATED {
6851 struct SubbandSize : asn::enumerated<5, 0, true>
6853 static constexpr const char* name() {return "SubbandSize";}
6854 using parent_t = asn::enumerated<5, 0, true>;
6866 SubbandCQICodeword0 ::= CHOICE {
6867 four-bitCQI INTEGER (0..15, ...),
6868 two-bitSubbandDifferentialCQI INTEGER (0..3, ...),
6869 two-bitDifferentialCQI INTEGER (0..3, ...),
6874 struct SubbandCQICodeword0 : asn::choice<3, 0, true>
6876 static constexpr const char* name() {return "SubbandCQICodeword0";}
6877 using parent_t = asn::choice<3, 0, true>;
6878 index_type get_index() const {return index;}
6879 bool is_unknown() const {return index == 4;}
6880 void set_unknown() { set_index(4); }
6881 ~SubbandCQICodeword0() {clear();}
6882 struct four_bitCQI_t : asn::integer<>
6884 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
6885 static constexpr const char* name() {return "four_bitCQI_t";}
6886 using parent_t = asn::integer<>;
6890 struct two_bitSubbandDifferentialCQI_t : asn::integer<>
6892 using constraint_t = asn::constraints<true,asn::span<0, 3>>;
6893 static constexpr const char* name() {return "two_bitSubbandDifferentialCQI_t";}
6894 using parent_t = asn::integer<>;
6898 struct two_bitDifferentialCQI_t : asn::integer<>
6900 using constraint_t = asn::constraints<true,asn::span<0, 3>>;
6901 static constexpr const char* name() {return "two_bitDifferentialCQI_t";}
6902 using parent_t = asn::integer<>;
6910 case 1: var.destroy<four_bitCQI_t>(); break;
6911 case 2: var.destroy<two_bitSubbandDifferentialCQI_t>(); break;
6912 case 3: var.destroy<two_bitDifferentialCQI_t>(); break;
6917 template<typename V> bool decode(size_t idx, V& v)
6922 case 1: set_index(1); return v(var.build<four_bitCQI_t>());
6923 case 2: set_index(2); return v(var.build<two_bitSubbandDifferentialCQI_t>());
6924 case 3: set_index(3); return v(var.build<two_bitDifferentialCQI_t>());
6929 template<typename V> bool encode(V& v) const
6933 case 1: return v(var.as<four_bitCQI_t>());
6934 case 2: return v(var.as<two_bitSubbandDifferentialCQI_t>());
6935 case 3: return v(var.as<two_bitDifferentialCQI_t>());
6939 template<typename V> static inline void enumerate(V& v)
6941 v.template operator()<four_bitCQI_t>(1);
6942 v.template operator()<two_bitSubbandDifferentialCQI_t>(2);
6943 v.template operator()<two_bitDifferentialCQI_t>(3);
6946 four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
6947 four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
6948 two_bitSubbandDifferentialCQI_t& select_two_bitSubbandDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<two_bitSubbandDifferentialCQI_t>();} return var.as<two_bitSubbandDifferentialCQI_t>();}
6949 two_bitSubbandDifferentialCQI_t const* get_two_bitSubbandDifferentialCQI() const { if(get_index() == 2) { return &var.as<two_bitSubbandDifferentialCQI_t>();} return nullptr; }
6950 two_bitDifferentialCQI_t& select_two_bitDifferentialCQI() { if(get_index() != 3) { clear(); set_index(3); return var.build<two_bitDifferentialCQI_t>();} return var.as<two_bitDifferentialCQI_t>();}
6951 two_bitDifferentialCQI_t const* get_two_bitDifferentialCQI() const { if(get_index() == 3) { return &var.as<two_bitDifferentialCQI_t>();} return nullptr; }
6953 void set_index(index_type i) {index = i; base::set();}
6956 char dummy1[sizeof(four_bitCQI_t)];
6957 char dummy2[sizeof(two_bitSubbandDifferentialCQI_t)];
6958 char dummy3[sizeof(two_bitDifferentialCQI_t)];
6961 asn::variant<sizeof(union_type)> var;
6962 index_type index {0};
6965 SubbandCQICodeword1 ::= CHOICE {
6966 four-bitCQI INTEGER (0..15, ...),
6967 three-bitSpatialDifferentialCQI INTEGER (0..7, ...),
6968 two-bitSubbandDifferentialCQI INTEGER (0..3, ...),
6969 two-bitDifferentialCQI INTEGER (0..3, ...),
6974 struct SubbandCQICodeword1 : asn::choice<4, 0, true>
6976 static constexpr const char* name() {return "SubbandCQICodeword1";}
6977 using parent_t = asn::choice<4, 0, true>;
6978 index_type get_index() const {return index;}
6979 bool is_unknown() const {return index == 5;}
6980 void set_unknown() { set_index(5); }
6981 ~SubbandCQICodeword1() {clear();}
6982 struct four_bitCQI_t : asn::integer<>
6984 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
6985 static constexpr const char* name() {return "four_bitCQI_t";}
6986 using parent_t = asn::integer<>;
6990 struct three_bitSpatialDifferentialCQI_t : asn::integer<>
6992 using constraint_t = asn::constraints<true,asn::span<0, 7>>;
6993 static constexpr const char* name() {return "three_bitSpatialDifferentialCQI_t";}
6994 using parent_t = asn::integer<>;
6998 struct two_bitSubbandDifferentialCQI_t : asn::integer<>
7000 using constraint_t = asn::constraints<true,asn::span<0, 3>>;
7001 static constexpr const char* name() {return "two_bitSubbandDifferentialCQI_t";}
7002 using parent_t = asn::integer<>;
7006 struct two_bitDifferentialCQI_t : asn::integer<>
7008 using constraint_t = asn::constraints<true,asn::span<0, 3>>;
7009 static constexpr const char* name() {return "two_bitDifferentialCQI_t";}
7010 using parent_t = asn::integer<>;
7018 case 1: var.destroy<four_bitCQI_t>(); break;
7019 case 2: var.destroy<three_bitSpatialDifferentialCQI_t>(); break;
7020 case 3: var.destroy<two_bitSubbandDifferentialCQI_t>(); break;
7021 case 4: var.destroy<two_bitDifferentialCQI_t>(); break;
7026 template<typename V> bool decode(size_t idx, V& v)
7031 case 1: set_index(1); return v(var.build<four_bitCQI_t>());
7032 case 2: set_index(2); return v(var.build<three_bitSpatialDifferentialCQI_t>());
7033 case 3: set_index(3); return v(var.build<two_bitSubbandDifferentialCQI_t>());
7034 case 4: set_index(4); return v(var.build<two_bitDifferentialCQI_t>());
7039 template<typename V> bool encode(V& v) const
7043 case 1: return v(var.as<four_bitCQI_t>());
7044 case 2: return v(var.as<three_bitSpatialDifferentialCQI_t>());
7045 case 3: return v(var.as<two_bitSubbandDifferentialCQI_t>());
7046 case 4: return v(var.as<two_bitDifferentialCQI_t>());
7050 template<typename V> static inline void enumerate(V& v)
7052 v.template operator()<four_bitCQI_t>(1);
7053 v.template operator()<three_bitSpatialDifferentialCQI_t>(2);
7054 v.template operator()<two_bitSubbandDifferentialCQI_t>(3);
7055 v.template operator()<two_bitDifferentialCQI_t>(4);
7058 four_bitCQI_t& select_four_bitCQI() { if(get_index() != 1) { clear(); set_index(1); return var.build<four_bitCQI_t>();} return var.as<four_bitCQI_t>();}
7059 four_bitCQI_t const* get_four_bitCQI() const { if(get_index() == 1) { return &var.as<four_bitCQI_t>();} return nullptr; }
7060 three_bitSpatialDifferentialCQI_t& select_three_bitSpatialDifferentialCQI() { if(get_index() != 2) { clear(); set_index(2); return var.build<three_bitSpatialDifferentialCQI_t>();} return var.as<three_bitSpatialDifferentialCQI_t>();}
7061 three_bitSpatialDifferentialCQI_t const* get_three_bitSpatialDifferentialCQI() const { if(get_index() == 2) { return &var.as<three_bitSpatialDifferentialCQI_t>();} return nullptr; }
7062 two_bitSubbandDifferentialCQI_t& select_two_bitSubbandDifferentialCQI() { if(get_index() != 3) { clear(); set_index(3); return var.build<two_bitSubbandDifferentialCQI_t>();} return var.as<two_bitSubbandDifferentialCQI_t>();}
7063 two_bitSubbandDifferentialCQI_t const* get_two_bitSubbandDifferentialCQI() const { if(get_index() == 3) { return &var.as<two_bitSubbandDifferentialCQI_t>();} return nullptr; }
7064 two_bitDifferentialCQI_t& select_two_bitDifferentialCQI() { if(get_index() != 4) { clear(); set_index(4); return var.build<two_bitDifferentialCQI_t>();} return var.as<two_bitDifferentialCQI_t>();}
7065 two_bitDifferentialCQI_t const* get_two_bitDifferentialCQI() const { if(get_index() == 4) { return &var.as<two_bitDifferentialCQI_t>();} return nullptr; }
7067 void set_index(index_type i) {index = i; base::set();}
7070 char dummy1[sizeof(four_bitCQI_t)];
7071 char dummy2[sizeof(three_bitSpatialDifferentialCQI_t)];
7072 char dummy3[sizeof(two_bitSubbandDifferentialCQI_t)];
7073 char dummy4[sizeof(two_bitDifferentialCQI_t)];
7076 asn::variant<sizeof(union_type)> var;
7077 index_type index {0};
7080 SubbandCQI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7085 struct SubbandCQI_ExtIEs
7087 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7089 size_t get_index() const {return type;}
7090 bool is_unknown() const { return type == 1; }
7091 void clear() {type = 0;}
7092 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7093 template<typename V> bool decode(V& v)
7096 if(!v(ref_nested())) return false;
7097 { type = 1; return true;}
7101 template<typename V> bool encode(V& v) const
7103 return v(ref_nested());
7107 template<typename V> bool decode(size_t index, V& v)
7112 case 1: type = 1; return v(ref_nested());
7113 ref_nested().clear();
7118 template<typename V> bool encode(size_t index, V& v) const
7120 if(index != type) {return false;} return v(ref_nested());
7127 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7129 size_t get_index() const {return type;}
7130 bool is_unknown() const { return type == 1; }
7131 void clear() {type = 0;}
7132 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7133 template<typename V> bool decode(V& v)
7136 if(!v(ref_nested())) return false;
7137 { type = 1; return true;}
7141 template<typename V> bool encode(V& v) const
7143 return v(ref_nested());
7147 template<typename V> bool decode(size_t index, V& v)
7152 case 1: type = 1; return v(ref_nested());
7153 ref_nested().clear();
7158 template<typename V> bool encode(size_t index, V& v) const
7160 if(index != type) {return false;} return v(ref_nested());
7167 struct Extension_t : asn::typefield<true>
7169 ~Extension_t() {clear();}
7170 size_t get_index() const {return type;}
7171 bool is_unknown() const { return type == 1; }
7174 type = 0; ref_nested().clear();
7176 template<typename V> static inline void enumerate(V& v)
7181 template<typename V> bool decode(size_t index, V& v)
7186 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
7191 template<typename V> bool encode(size_t index, V& v) const
7193 if(index != type) return false;
7201 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7203 size_t get_index() const {return type;}
7204 bool is_unknown() const { return type == 1; }
7205 void clear() {type = 0;}
7206 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7207 template<typename V> bool decode(V& v)
7210 if(!v(ref_nested())) return false;
7211 { type = 1; return true;}
7215 template<typename V> bool encode(V& v) const
7217 return v(ref_nested());
7221 template<typename V> bool decode(size_t index, V& v)
7226 case 1: type = 1; return v(ref_nested());
7227 ref_nested().clear();
7232 template<typename V> bool encode(size_t index, V& v) const
7234 if(index != type) {return false;} return v(ref_nested());
7244 SubbandCQI ::= SEQUENCE {
7245 subbandCQICodeword0 SubbandCQICodeword0,
7246 subbandCQICodeword1 SubbandCQICodeword1 OPTIONAL,
7247 iE-Extensions ProtocolExtensionContainer { {SubbandCQI-ExtIEs} } OPTIONAL,
7252 struct SubbandCQI : asn::sequence<3, 0, true, 2>
7254 static constexpr const char* name() {return "SubbandCQI";}
7255 using parent_t = asn::sequence<3, 0, true, 2>;
7256 struct subbandCQICodeword0_t : SubbandCQICodeword0
7258 static constexpr const char* name() {return "subbandCQICodeword0_t";}
7259 using parent_t = SubbandCQICodeword0;
7262 subbandCQICodeword0_t& ref_subbandCQICodeword0() {return subbandCQICodeword0;}
7263 subbandCQICodeword0_t const& ref_subbandCQICodeword0() const {return subbandCQICodeword0;}
7264 struct subbandCQICodeword1_t : SubbandCQICodeword1
7266 static constexpr const char* name() {return "subbandCQICodeword1_t";}
7267 using parent_t = SubbandCQICodeword1;
7268 static constexpr bool optional = true;
7271 subbandCQICodeword1_t& set_subbandCQICodeword1() { subbandCQICodeword1.setpresent(true); return subbandCQICodeword1;}
7272 subbandCQICodeword1_t const* get_subbandCQICodeword1() const {return subbandCQICodeword1.is_valid() ? &subbandCQICodeword1 : nullptr;}
7273 struct iE_Extensions_t : ProtocolExtensionContainer<SubbandCQI_ExtIEs>
7275 static constexpr const char* name() {return "iE_Extensions_t";}
7276 using parent_t = ProtocolExtensionContainer<SubbandCQI_ExtIEs>;
7277 static constexpr bool optional = true;
7280 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7281 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7282 template<typename V> void decode(V& v)
7284 v(subbandCQICodeword0);
7285 v(subbandCQICodeword1);
7289 template<typename V> void encode(V& v) const
7291 v(subbandCQICodeword0);
7292 v(subbandCQICodeword1);
7298 subbandCQICodeword0.clear();
7299 subbandCQICodeword1.clear();
7300 iE_Extensions.clear();
7304 subbandCQICodeword0_t subbandCQICodeword0;
7305 subbandCQICodeword1_t subbandCQICodeword1;
7306 iE_Extensions_t iE_Extensions;
7310 SubbandCQIItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7315 struct SubbandCQIItem_ExtIEs
7317 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7319 size_t get_index() const {return type;}
7320 bool is_unknown() const { return type == 1; }
7321 void clear() {type = 0;}
7322 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7323 template<typename V> bool decode(V& v)
7326 if(!v(ref_nested())) return false;
7327 { type = 1; return true;}
7331 template<typename V> bool encode(V& v) const
7333 return v(ref_nested());
7337 template<typename V> bool decode(size_t index, V& v)
7342 case 1: type = 1; return v(ref_nested());
7343 ref_nested().clear();
7348 template<typename V> bool encode(size_t index, V& v) const
7350 if(index != type) {return false;} return v(ref_nested());
7357 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7359 size_t get_index() const {return type;}
7360 bool is_unknown() const { return type == 1; }
7361 void clear() {type = 0;}
7362 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7363 template<typename V> bool decode(V& v)
7366 if(!v(ref_nested())) return false;
7367 { type = 1; return true;}
7371 template<typename V> bool encode(V& v) const
7373 return v(ref_nested());
7377 template<typename V> bool decode(size_t index, V& v)
7382 case 1: type = 1; return v(ref_nested());
7383 ref_nested().clear();
7388 template<typename V> bool encode(size_t index, V& v) const
7390 if(index != type) {return false;} return v(ref_nested());
7397 struct Extension_t : asn::typefield<true>
7399 ~Extension_t() {clear();}
7400 size_t get_index() const {return type;}
7401 bool is_unknown() const { return type == 1; }
7404 type = 0; ref_nested().clear();
7406 template<typename V> static inline void enumerate(V& v)
7411 template<typename V> bool decode(size_t index, V& v)
7416 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
7421 template<typename V> bool encode(size_t index, V& v) const
7423 if(index != type) return false;
7431 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7433 size_t get_index() const {return type;}
7434 bool is_unknown() const { return type == 1; }
7435 void clear() {type = 0;}
7436 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7437 template<typename V> bool decode(V& v)
7440 if(!v(ref_nested())) return false;
7441 { type = 1; return true;}
7445 template<typename V> bool encode(V& v) const
7447 return v(ref_nested());
7451 template<typename V> bool decode(size_t index, V& v)
7456 case 1: type = 1; return v(ref_nested());
7457 ref_nested().clear();
7462 template<typename V> bool encode(size_t index, V& v) const
7464 if(index != type) {return false;} return v(ref_nested());
7474 SubbandCQIItem ::= SEQUENCE {
7475 subbandCQI SubbandCQI,
7476 subbandIndex INTEGER (0..27,...),
7477 iE-Extensions ProtocolExtensionContainer { {SubbandCQIItem-ExtIEs} } OPTIONAL,
7482 struct SubbandCQIItem : asn::sequence<3, 0, true, 1>
7484 static constexpr const char* name() {return "SubbandCQIItem";}
7485 using parent_t = asn::sequence<3, 0, true, 1>;
7486 struct subbandCQI_t : SubbandCQI
7488 static constexpr const char* name() {return "subbandCQI_t";}
7489 using parent_t = SubbandCQI;
7492 subbandCQI_t& ref_subbandCQI() {return subbandCQI;}
7493 subbandCQI_t const& ref_subbandCQI() const {return subbandCQI;}
7494 struct subbandIndex_t : asn::integer<>
7496 using constraint_t = asn::constraints<true,asn::span<0, 27>>;
7497 static constexpr const char* name() {return "subbandIndex_t";}
7498 using parent_t = asn::integer<>;
7502 subbandIndex_t& ref_subbandIndex() {return subbandIndex;}
7503 subbandIndex_t const& ref_subbandIndex() const {return subbandIndex;}
7504 struct iE_Extensions_t : ProtocolExtensionContainer<SubbandCQIItem_ExtIEs>
7506 static constexpr const char* name() {return "iE_Extensions_t";}
7507 using parent_t = ProtocolExtensionContainer<SubbandCQIItem_ExtIEs>;
7508 static constexpr bool optional = true;
7511 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7512 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7513 template<typename V> void decode(V& v)
7520 template<typename V> void encode(V& v) const
7530 subbandIndex.clear();
7531 iE_Extensions.clear();
7535 subbandCQI_t subbandCQI;
7536 subbandIndex_t subbandIndex;
7537 iE_Extensions_t iE_Extensions;
7541 SubbandCQIList ::= SEQUENCE (SIZE(1.. maxSubband)) OF SubbandCQIItem
7544 struct SubbandCQIList_elm : SubbandCQIItem
7546 static constexpr const char* name() {return "SubbandCQIList_elm";}
7547 using parent_t = SubbandCQIItem;
7550 struct SubbandCQIList : asn::sequenceof<SubbandCQIList_elm>
7552 static constexpr const char* name() {return "SubbandCQIList";}
7553 using parent_t = asn::sequenceof<SubbandCQIList_elm>;
7554 using constraint_t = asn::constraints<false,asn::span<1, maxSubband >>;
7558 CSIReportPerCSIProcessItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7563 struct CSIReportPerCSIProcessItem_ExtIEs
7565 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7567 size_t get_index() const {return type;}
7568 bool is_unknown() const { return type == 1; }
7569 void clear() {type = 0;}
7570 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7571 template<typename V> bool decode(V& v)
7574 if(!v(ref_nested())) return false;
7575 { type = 1; return true;}
7579 template<typename V> bool encode(V& v) const
7581 return v(ref_nested());
7585 template<typename V> bool decode(size_t index, V& v)
7590 case 1: type = 1; return v(ref_nested());
7591 ref_nested().clear();
7596 template<typename V> bool encode(size_t index, V& v) const
7598 if(index != type) {return false;} return v(ref_nested());
7605 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7607 size_t get_index() const {return type;}
7608 bool is_unknown() const { return type == 1; }
7609 void clear() {type = 0;}
7610 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7611 template<typename V> bool decode(V& v)
7614 if(!v(ref_nested())) return false;
7615 { type = 1; return true;}
7619 template<typename V> bool encode(V& v) const
7621 return v(ref_nested());
7625 template<typename V> bool decode(size_t index, V& v)
7630 case 1: type = 1; return v(ref_nested());
7631 ref_nested().clear();
7636 template<typename V> bool encode(size_t index, V& v) const
7638 if(index != type) {return false;} return v(ref_nested());
7645 struct Extension_t : asn::typefield<true>
7647 ~Extension_t() {clear();}
7648 size_t get_index() const {return type;}
7649 bool is_unknown() const { return type == 1; }
7652 type = 0; ref_nested().clear();
7654 template<typename V> static inline void enumerate(V& v)
7659 template<typename V> bool decode(size_t index, V& v)
7664 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
7669 template<typename V> bool encode(size_t index, V& v) const
7671 if(index != type) return false;
7679 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7681 size_t get_index() const {return type;}
7682 bool is_unknown() const { return type == 1; }
7683 void clear() {type = 0;}
7684 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7685 template<typename V> bool decode(V& v)
7688 if(!v(ref_nested())) return false;
7689 { type = 1; return true;}
7693 template<typename V> bool encode(V& v) const
7695 return v(ref_nested());
7699 template<typename V> bool decode(size_t index, V& v)
7704 case 1: type = 1; return v(ref_nested());
7705 ref_nested().clear();
7710 template<typename V> bool encode(size_t index, V& v) const
7712 if(index != type) {return false;} return v(ref_nested());
7722 CSIReportPerCSIProcessItem ::= SEQUENCE (SIZE(1.. maxCSIReport)) OF
7724 rI INTEGER (1..8, ...),
7725 widebandCQI WidebandCQI,
7726 subbandSize SubbandSize,
7727 subbandCQIList SubbandCQIList OPTIONAL,
7728 iE-Extensions ProtocolExtensionContainer { {CSIReportPerCSIProcessItem-ExtIEs} } OPTIONAL,
7733 struct CSIReportPerCSIProcessItem_elm : asn::sequence<5, 0, true, 2>
7735 static constexpr const char* name() {return "CSIReportPerCSIProcessItem_elm";}
7736 using parent_t = asn::sequence<5, 0, true, 2>;
7737 struct rI_t : asn::integer<>
7739 using constraint_t = asn::constraints<true,asn::span<1, 8>>;
7740 static constexpr const char* name() {return "rI_t";}
7741 using parent_t = asn::integer<>;
7745 rI_t& ref_rI() {return rI;}
7746 rI_t const& ref_rI() const {return rI;}
7747 struct widebandCQI_t : WidebandCQI
7749 static constexpr const char* name() {return "widebandCQI_t";}
7750 using parent_t = WidebandCQI;
7753 widebandCQI_t& ref_widebandCQI() {return widebandCQI;}
7754 widebandCQI_t const& ref_widebandCQI() const {return widebandCQI;}
7755 struct subbandSize_t : SubbandSize
7757 static constexpr const char* name() {return "subbandSize_t";}
7758 using parent_t = SubbandSize;
7761 subbandSize_t& ref_subbandSize() {return subbandSize;}
7762 subbandSize_t const& ref_subbandSize() const {return subbandSize;}
7763 struct subbandCQIList_t : SubbandCQIList
7765 static constexpr const char* name() {return "subbandCQIList_t";}
7766 using parent_t = SubbandCQIList;
7767 static constexpr bool optional = true;
7770 subbandCQIList_t& set_subbandCQIList() { subbandCQIList.setpresent(true); return subbandCQIList;}
7771 subbandCQIList_t const* get_subbandCQIList() const {return subbandCQIList.is_valid() ? &subbandCQIList : nullptr;}
7772 struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportPerCSIProcessItem_ExtIEs>
7774 static constexpr const char* name() {return "iE_Extensions_t";}
7775 using parent_t = ProtocolExtensionContainer<CSIReportPerCSIProcessItem_ExtIEs>;
7776 static constexpr bool optional = true;
7779 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
7780 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
7781 template<typename V> void decode(V& v)
7790 template<typename V> void encode(V& v) const
7802 widebandCQI.clear();
7803 subbandSize.clear();
7804 subbandCQIList.clear();
7805 iE_Extensions.clear();
7810 widebandCQI_t widebandCQI;
7811 subbandSize_t subbandSize;
7812 subbandCQIList_t subbandCQIList;
7813 iE_Extensions_t iE_Extensions;
7816 struct CSIReportPerCSIProcessItem : asn::sequenceof<CSIReportPerCSIProcessItem_elm>
7818 static constexpr const char* name() {return "CSIReportPerCSIProcessItem";}
7819 using parent_t = asn::sequenceof<CSIReportPerCSIProcessItem_elm>;
7820 using constraint_t = asn::constraints<false,asn::span<1, maxCSIReport >>;
7824 CSIReportPerCSIProcess-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
7829 struct CSIReportPerCSIProcess_ExtIEs
7831 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
7833 size_t get_index() const {return type;}
7834 bool is_unknown() const { return type == 1; }
7835 void clear() {type = 0;}
7836 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
7837 template<typename V> bool decode(V& v)
7840 if(!v(ref_nested())) return false;
7841 { type = 1; return true;}
7845 template<typename V> bool encode(V& v) const
7847 return v(ref_nested());
7851 template<typename V> bool decode(size_t index, V& v)
7856 case 1: type = 1; return v(ref_nested());
7857 ref_nested().clear();
7862 template<typename V> bool encode(size_t index, V& v) const
7864 if(index != type) {return false;} return v(ref_nested());
7871 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
7873 size_t get_index() const {return type;}
7874 bool is_unknown() const { return type == 1; }
7875 void clear() {type = 0;}
7876 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
7877 template<typename V> bool decode(V& v)
7880 if(!v(ref_nested())) return false;
7881 { type = 1; return true;}
7885 template<typename V> bool encode(V& v) const
7887 return v(ref_nested());
7891 template<typename V> bool decode(size_t index, V& v)
7896 case 1: type = 1; return v(ref_nested());
7897 ref_nested().clear();
7902 template<typename V> bool encode(size_t index, V& v) const
7904 if(index != type) {return false;} return v(ref_nested());
7911 struct Extension_t : asn::typefield<true>
7913 ~Extension_t() {clear();}
7914 size_t get_index() const {return type;}
7915 bool is_unknown() const { return type == 1; }
7918 type = 0; ref_nested().clear();
7920 template<typename V> static inline void enumerate(V& v)
7925 template<typename V> bool decode(size_t index, V& v)
7930 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
7935 template<typename V> bool encode(size_t index, V& v) const
7937 if(index != type) return false;
7945 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
7947 size_t get_index() const {return type;}
7948 bool is_unknown() const { return type == 1; }
7949 void clear() {type = 0;}
7950 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
7951 template<typename V> bool decode(V& v)
7954 if(!v(ref_nested())) return false;
7955 { type = 1; return true;}
7959 template<typename V> bool encode(V& v) const
7961 return v(ref_nested());
7965 template<typename V> bool decode(size_t index, V& v)
7970 case 1: type = 1; return v(ref_nested());
7971 ref_nested().clear();
7976 template<typename V> bool encode(size_t index, V& v) const
7978 if(index != type) {return false;} return v(ref_nested());
7988 CSIReportPerCSIProcess ::= SEQUENCE (SIZE(1.. maxCSIProcess)) OF
7990 cSIProcessConfigurationIndex INTEGER (1..7, ...),
7991 cSIReportPerCSIProcessItem CSIReportPerCSIProcessItem,
7992 iE-Extensions ProtocolExtensionContainer { {CSIReportPerCSIProcess-ExtIEs} } OPTIONAL,
7997 struct CSIReportPerCSIProcess_elm : asn::sequence<3, 0, true, 1>
7999 static constexpr const char* name() {return "CSIReportPerCSIProcess_elm";}
8000 using parent_t = asn::sequence<3, 0, true, 1>;
8001 struct cSIProcessConfigurationIndex_t : asn::integer<>
8003 using constraint_t = asn::constraints<true,asn::span<1, 7>>;
8004 static constexpr const char* name() {return "cSIProcessConfigurationIndex_t";}
8005 using parent_t = asn::integer<>;
8009 cSIProcessConfigurationIndex_t& ref_cSIProcessConfigurationIndex() {return cSIProcessConfigurationIndex;}
8010 cSIProcessConfigurationIndex_t const& ref_cSIProcessConfigurationIndex() const {return cSIProcessConfigurationIndex;}
8011 struct cSIReportPerCSIProcessItem_t : CSIReportPerCSIProcessItem
8013 static constexpr const char* name() {return "cSIReportPerCSIProcessItem_t";}
8014 using parent_t = CSIReportPerCSIProcessItem;
8017 cSIReportPerCSIProcessItem_t& ref_cSIReportPerCSIProcessItem() {return cSIReportPerCSIProcessItem;}
8018 cSIReportPerCSIProcessItem_t const& ref_cSIReportPerCSIProcessItem() const {return cSIReportPerCSIProcessItem;}
8019 struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportPerCSIProcess_ExtIEs>
8021 static constexpr const char* name() {return "iE_Extensions_t";}
8022 using parent_t = ProtocolExtensionContainer<CSIReportPerCSIProcess_ExtIEs>;
8023 static constexpr bool optional = true;
8026 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8027 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8028 template<typename V> void decode(V& v)
8030 v(cSIProcessConfigurationIndex);
8031 v(cSIReportPerCSIProcessItem);
8035 template<typename V> void encode(V& v) const
8037 v(cSIProcessConfigurationIndex);
8038 v(cSIReportPerCSIProcessItem);
8044 cSIProcessConfigurationIndex.clear();
8045 cSIReportPerCSIProcessItem.clear();
8046 iE_Extensions.clear();
8050 cSIProcessConfigurationIndex_t cSIProcessConfigurationIndex;
8051 cSIReportPerCSIProcessItem_t cSIReportPerCSIProcessItem;
8052 iE_Extensions_t iE_Extensions;
8055 struct CSIReportPerCSIProcess : asn::sequenceof<CSIReportPerCSIProcess_elm>
8057 static constexpr const char* name() {return "CSIReportPerCSIProcess";}
8058 using parent_t = asn::sequenceof<CSIReportPerCSIProcess_elm>;
8059 using constraint_t = asn::constraints<false,asn::span<1, maxCSIProcess >>;
8063 CSIReportList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
8068 struct CSIReportList_ExtIEs
8070 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
8072 size_t get_index() const {return type;}
8073 bool is_unknown() const { return type == 1; }
8074 void clear() {type = 0;}
8075 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
8076 template<typename V> bool decode(V& v)
8079 if(!v(ref_nested())) return false;
8080 { type = 1; return true;}
8084 template<typename V> bool encode(V& v) const
8086 return v(ref_nested());
8090 template<typename V> bool decode(size_t index, V& v)
8095 case 1: type = 1; return v(ref_nested());
8096 ref_nested().clear();
8101 template<typename V> bool encode(size_t index, V& v) const
8103 if(index != type) {return false;} return v(ref_nested());
8110 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8112 size_t get_index() const {return type;}
8113 bool is_unknown() const { return type == 1; }
8114 void clear() {type = 0;}
8115 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8116 template<typename V> bool decode(V& v)
8119 if(!v(ref_nested())) return false;
8120 { type = 1; return true;}
8124 template<typename V> bool encode(V& v) const
8126 return v(ref_nested());
8130 template<typename V> bool decode(size_t index, V& v)
8135 case 1: type = 1; return v(ref_nested());
8136 ref_nested().clear();
8141 template<typename V> bool encode(size_t index, V& v) const
8143 if(index != type) {return false;} return v(ref_nested());
8150 struct Extension_t : asn::typefield<true>
8152 ~Extension_t() {clear();}
8153 size_t get_index() const {return type;}
8154 bool is_unknown() const { return type == 1; }
8157 type = 0; ref_nested().clear();
8159 template<typename V> static inline void enumerate(V& v)
8164 template<typename V> bool decode(size_t index, V& v)
8169 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
8174 template<typename V> bool encode(size_t index, V& v) const
8176 if(index != type) return false;
8184 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
8186 size_t get_index() const {return type;}
8187 bool is_unknown() const { return type == 1; }
8188 void clear() {type = 0;}
8189 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
8190 template<typename V> bool decode(V& v)
8193 if(!v(ref_nested())) return false;
8194 { type = 1; return true;}
8198 template<typename V> bool encode(V& v) const
8200 return v(ref_nested());
8204 template<typename V> bool decode(size_t index, V& v)
8209 case 1: type = 1; return v(ref_nested());
8210 ref_nested().clear();
8215 template<typename V> bool encode(size_t index, V& v) const
8217 if(index != type) {return false;} return v(ref_nested());
8227 CSIReportList ::= SEQUENCE (SIZE(1..maxUEReport)) OF
8230 cSIReportPerCSIProcess CSIReportPerCSIProcess,
8231 iE-Extensions ProtocolExtensionContainer { {CSIReportList-ExtIEs} } OPTIONAL,
8236 struct CSIReportList_elm : asn::sequence<3, 0, true, 1>
8238 static constexpr const char* name() {return "CSIReportList_elm";}
8239 using parent_t = asn::sequence<3, 0, true, 1>;
8240 struct uEID_t : UEID
8242 static constexpr const char* name() {return "uEID_t";}
8243 using parent_t = UEID;
8246 uEID_t& ref_uEID() {return uEID;}
8247 uEID_t const& ref_uEID() const {return uEID;}
8248 struct cSIReportPerCSIProcess_t : CSIReportPerCSIProcess
8250 static constexpr const char* name() {return "cSIReportPerCSIProcess_t";}
8251 using parent_t = CSIReportPerCSIProcess;
8254 cSIReportPerCSIProcess_t& ref_cSIReportPerCSIProcess() {return cSIReportPerCSIProcess;}
8255 cSIReportPerCSIProcess_t const& ref_cSIReportPerCSIProcess() const {return cSIReportPerCSIProcess;}
8256 struct iE_Extensions_t : ProtocolExtensionContainer<CSIReportList_ExtIEs>
8258 static constexpr const char* name() {return "iE_Extensions_t";}
8259 using parent_t = ProtocolExtensionContainer<CSIReportList_ExtIEs>;
8260 static constexpr bool optional = true;
8263 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8264 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8265 template<typename V> void decode(V& v)
8268 v(cSIReportPerCSIProcess);
8272 template<typename V> void encode(V& v) const
8275 v(cSIReportPerCSIProcess);
8282 cSIReportPerCSIProcess.clear();
8283 iE_Extensions.clear();
8288 cSIReportPerCSIProcess_t cSIReportPerCSIProcess;
8289 iE_Extensions_t iE_Extensions;
8292 struct CSIReportList : asn::sequenceof<CSIReportList_elm>
8294 static constexpr const char* name() {return "CSIReportList";}
8295 using parent_t = asn::sequenceof<CSIReportList_elm>;
8296 using constraint_t = asn::constraints<false,asn::span<1, maxUEReport >>;
8300 CapacityValue ::= INTEGER (0..100)
8303 struct CapacityValue : asn::integer<>
8305 using constraint_t = asn::constraints<false,asn::span<0, 100>>;
8306 static constexpr const char* name() {return "CapacityValue";}
8307 using parent_t = asn::integer<>;
8312 CauseRadioNetwork ::= ENUMERATED {
8313 handover-desirable-for-radio-reasons,
8314 time-critical-handover,
8315 resource-optimisation-handover,
8316 reduce-load-in-serving-cell,
8318 unknown-new-eNB-UE-X2AP-ID,
8319 unknown-old-eNB-UE-X2AP-ID,
8320 unknown-pair-of-UE-X2AP-ID,
8321 ho-target-not-allowed,
8322 tx2relocoverall-expiry,
8325 no-radio-resources-available-in-target-cell,
8326 invalid-MME-GroupID,
8328 encryption-and-or-integrity-protection-algorithms-not-supported,
8329 reportCharacteristicsEmpty,
8330 noReportPeriodicity,
8331 existingMeasurementID,
8332 unknown-eNB-Measurement-ID,
8333 measurement-temporarily-not-available,
8337 handover-optimisation,
8338 value-out-of-allowed-range,
8339 multiple-E-RAB-ID-instances,
8341 not-supported-QCI-value,
8342 measurement-not-supported-for-the-object,
8345 action-desirable-for-radio-reasons,
8347 resource-optimisation,
8348 time-critical-action,
8350 no-radio-resources-available,
8351 invalid-QoS-combination,
8352 encryption-algorithms-not-aupported,
8353 procedure-cancelled,
8355 improve-user-bit-rate,
8357 radio-connection-with-UE-lost,
8358 failure-in-the-radio-interface-procedure,
8359 bearer-option-not-supported,
8362 count-reaches-max-value,
8363 unknown-old-en-gNB-UE-X2AP-ID,
8369 struct CauseRadioNetwork : asn::enumerated<51, 29, true>
8371 static constexpr const char* name() {return "CauseRadioNetwork";}
8372 using parent_t = asn::enumerated<51, 29, true>;
8374 handover_desirable_for_radio_reasons
8375 ,time_critical_handover
8376 ,resource_optimisation_handover
8377 ,reduce_load_in_serving_cell
8379 ,unknown_new_eNB_UE_X2AP_ID
8380 ,unknown_old_eNB_UE_X2AP_ID
8381 ,unknown_pair_of_UE_X2AP_ID
8382 ,ho_target_not_allowed
8383 ,tx2relocoverall_expiry
8386 ,no_radio_resources_available_in_target_cell
8387 ,invalid_MME_GroupID
8389 ,encryption_and_or_integrity_protection_algorithms_not_supported
8390 ,reportCharacteristicsEmpty
8391 ,noReportPeriodicity
8392 ,existingMeasurementID
8393 ,unknown_eNB_Measurement_ID
8394 ,measurement_temporarily_not_available
8397 ,handover_optimisation
8398 ,value_out_of_allowed_range
8399 ,multiple_E_RAB_ID_instances
8401 ,not_supported_QCI_value
8402 ,measurement_not_supported_for_the_object
8405 ,action_desirable_for_radio_reasons
8407 ,resource_optimisation
8408 ,time_critical_action
8410 ,no_radio_resources_available
8411 ,invalid_QoS_combination
8412 ,encryption_algorithms_not_aupported
8413 ,procedure_cancelled
8415 ,improve_user_bit_rate
8417 ,radio_connection_with_UE_lost
8418 ,failure_in_the_radio_interface_procedure
8419 ,bearer_option_not_supported
8422 ,count_reaches_max_value
8423 ,unknown_old_en_gNB_UE_X2AP_ID
8430 CauseTransport ::= ENUMERATED {
8431 transport-resource-unavailable,
8437 struct CauseTransport : asn::enumerated<2, 0, true>
8439 static constexpr const char* name() {return "CauseTransport";}
8440 using parent_t = asn::enumerated<2, 0, true>;
8442 transport_resource_unavailable
8449 CauseProtocol ::= ENUMERATED {
8450 transfer-syntax-error,
8451 abstract-syntax-error-reject,
8452 abstract-syntax-error-ignore-and-notify,
8453 message-not-compatible-with-receiver-state,
8456 abstract-syntax-error-falsely-constructed-message,
8461 struct CauseProtocol : asn::enumerated<7, 0, true>
8463 static constexpr const char* name() {return "CauseProtocol";}
8464 using parent_t = asn::enumerated<7, 0, true>;
8466 transfer_syntax_error
8467 ,abstract_syntax_error_reject
8468 ,abstract_syntax_error_ignore_and_notify
8469 ,message_not_compatible_with_receiver_state
8472 ,abstract_syntax_error_falsely_constructed_message
8478 CauseMisc ::= ENUMERATED {
8479 control-processing-overload,
8482 not-enough-user-plane-processing-resources,
8488 struct CauseMisc : asn::enumerated<5, 0, true>
8490 static constexpr const char* name() {return "CauseMisc";}
8491 using parent_t = asn::enumerated<5, 0, true>;
8493 control_processing_overload
8496 ,not_enough_user_plane_processing_resources
8504 radioNetwork CauseRadioNetwork,
8505 transport CauseTransport,
8506 protocol CauseProtocol,
8512 struct Cause : asn::choice<4, 0, true>
8514 static constexpr const char* name() {return "Cause";}
8515 using parent_t = asn::choice<4, 0, true>;
8516 index_type get_index() const {return index;}
8517 bool is_unknown() const {return index == 5;}
8518 void set_unknown() { set_index(5); }
8520 struct radioNetwork_t : CauseRadioNetwork
8522 static constexpr const char* name() {return "radioNetwork_t";}
8523 using parent_t = CauseRadioNetwork;
8526 struct transport_t : CauseTransport
8528 static constexpr const char* name() {return "transport_t";}
8529 using parent_t = CauseTransport;
8532 struct protocol_t : CauseProtocol
8534 static constexpr const char* name() {return "protocol_t";}
8535 using parent_t = CauseProtocol;
8538 struct misc_t : CauseMisc
8540 static constexpr const char* name() {return "misc_t";}
8541 using parent_t = CauseMisc;
8548 case 1: var.destroy<radioNetwork_t>(); break;
8549 case 2: var.destroy<transport_t>(); break;
8550 case 3: var.destroy<protocol_t>(); break;
8551 case 4: var.destroy<misc_t>(); break;
8556 template<typename V> bool decode(size_t idx, V& v)
8561 case 1: set_index(1); return v(var.build<radioNetwork_t>());
8562 case 2: set_index(2); return v(var.build<transport_t>());
8563 case 3: set_index(3); return v(var.build<protocol_t>());
8564 case 4: set_index(4); return v(var.build<misc_t>());
8569 template<typename V> bool encode(V& v) const
8573 case 1: return v(var.as<radioNetwork_t>());
8574 case 2: return v(var.as<transport_t>());
8575 case 3: return v(var.as<protocol_t>());
8576 case 4: return v(var.as<misc_t>());
8580 template<typename V> static inline void enumerate(V& v)
8582 v.template operator()<radioNetwork_t>(1);
8583 v.template operator()<transport_t>(2);
8584 v.template operator()<protocol_t>(3);
8585 v.template operator()<misc_t>(4);
8588 radioNetwork_t& select_radioNetwork() { if(get_index() != 1) { clear(); set_index(1); return var.build<radioNetwork_t>();} return var.as<radioNetwork_t>();}
8589 radioNetwork_t const* get_radioNetwork() const { if(get_index() == 1) { return &var.as<radioNetwork_t>();} return nullptr; }
8590 transport_t& select_transport() { if(get_index() != 2) { clear(); set_index(2); return var.build<transport_t>();} return var.as<transport_t>();}
8591 transport_t const* get_transport() const { if(get_index() == 2) { return &var.as<transport_t>();} return nullptr; }
8592 protocol_t& select_protocol() { if(get_index() != 3) { clear(); set_index(3); return var.build<protocol_t>();} return var.as<protocol_t>();}
8593 protocol_t const* get_protocol() const { if(get_index() == 3) { return &var.as<protocol_t>();} return nullptr; }
8594 misc_t& select_misc() { if(get_index() != 4) { clear(); set_index(4); return var.build<misc_t>();} return var.as<misc_t>();}
8595 misc_t const* get_misc() const { if(get_index() == 4) { return &var.as<misc_t>();} return nullptr; }
8597 void set_index(index_type i) {index = i; base::set();}
8600 char dummy1[sizeof(radioNetwork_t)];
8601 char dummy2[sizeof(transport_t)];
8602 char dummy3[sizeof(protocol_t)];
8603 char dummy4[sizeof(misc_t)];
8606 asn::variant<sizeof(union_type)> var;
8607 index_type index {0};
8610 Cell-Size ::= ENUMERATED {verysmall, small, medium, large, ... }
8613 struct Cell_Size : asn::enumerated<4, 0, true>
8615 static constexpr const char* name() {return "Cell-Size";}
8616 using parent_t = asn::enumerated<4, 0, true>;
8627 CellCapacityClassValue ::= INTEGER (1..100, ...)
8630 struct CellCapacityClassValue : asn::integer<>
8632 using constraint_t = asn::constraints<true,asn::span<1, 100>>;
8633 static constexpr const char* name() {return "CellCapacityClassValue";}
8634 using parent_t = asn::integer<>;
8639 CellDeploymentStatusIndicator ::= ENUMERATED {pre-change-notification, ...}
8642 struct CellDeploymentStatusIndicator : asn::enumerated<1, 0, true>
8644 static constexpr const char* name() {return "CellDeploymentStatusIndicator";}
8645 using parent_t = asn::enumerated<1, 0, true>;
8647 pre_change_notification
8653 ReplacingCellsList-Item ::= SEQUENCE {
8659 struct ReplacingCellsList_Item : asn::sequence<1, 0, true, 0>
8661 static constexpr const char* name() {return "ReplacingCellsList-Item";}
8662 using parent_t = asn::sequence<1, 0, true, 0>;
8663 struct eCGI_t : ECGI
8665 static constexpr const char* name() {return "eCGI_t";}
8666 using parent_t = ECGI;
8669 eCGI_t& ref_eCGI() {return eCGI;}
8670 eCGI_t const& ref_eCGI() const {return eCGI;}
8671 template<typename V> void decode(V& v)
8676 template<typename V> void encode(V& v) const
8691 ReplacingCellsList ::= SEQUENCE (SIZE(0.. maxCellineNB)) OF ReplacingCellsList-Item
8694 struct ReplacingCellsList_elm : ReplacingCellsList_Item
8696 static constexpr const char* name() {return "ReplacingCellsList_elm";}
8697 using parent_t = ReplacingCellsList_Item;
8700 struct ReplacingCellsList : asn::sequenceof<ReplacingCellsList_elm>
8702 static constexpr const char* name() {return "ReplacingCellsList";}
8703 using parent_t = asn::sequenceof<ReplacingCellsList_elm>;
8704 using constraint_t = asn::constraints<false,asn::span<0, maxCellineNB >>;
8708 CellReplacingInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
8713 struct CellReplacingInfo_ExtIEs
8715 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
8717 size_t get_index() const {return type;}
8718 bool is_unknown() const { return type == 1; }
8719 void clear() {type = 0;}
8720 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
8721 template<typename V> bool decode(V& v)
8724 if(!v(ref_nested())) return false;
8725 { type = 1; return true;}
8729 template<typename V> bool encode(V& v) const
8731 return v(ref_nested());
8735 template<typename V> bool decode(size_t index, V& v)
8740 case 1: type = 1; return v(ref_nested());
8741 ref_nested().clear();
8746 template<typename V> bool encode(size_t index, V& v) const
8748 if(index != type) {return false;} return v(ref_nested());
8755 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8757 size_t get_index() const {return type;}
8758 bool is_unknown() const { return type == 1; }
8759 void clear() {type = 0;}
8760 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8761 template<typename V> bool decode(V& v)
8764 if(!v(ref_nested())) return false;
8765 { type = 1; return true;}
8769 template<typename V> bool encode(V& v) const
8771 return v(ref_nested());
8775 template<typename V> bool decode(size_t index, V& v)
8780 case 1: type = 1; return v(ref_nested());
8781 ref_nested().clear();
8786 template<typename V> bool encode(size_t index, V& v) const
8788 if(index != type) {return false;} return v(ref_nested());
8795 struct Extension_t : asn::typefield<true>
8797 ~Extension_t() {clear();}
8798 size_t get_index() const {return type;}
8799 bool is_unknown() const { return type == 1; }
8802 type = 0; ref_nested().clear();
8804 template<typename V> static inline void enumerate(V& v)
8809 template<typename V> bool decode(size_t index, V& v)
8814 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
8819 template<typename V> bool encode(size_t index, V& v) const
8821 if(index != type) return false;
8829 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
8831 size_t get_index() const {return type;}
8832 bool is_unknown() const { return type == 1; }
8833 void clear() {type = 0;}
8834 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
8835 template<typename V> bool decode(V& v)
8838 if(!v(ref_nested())) return false;
8839 { type = 1; return true;}
8843 template<typename V> bool encode(V& v) const
8845 return v(ref_nested());
8849 template<typename V> bool decode(size_t index, V& v)
8854 case 1: type = 1; return v(ref_nested());
8855 ref_nested().clear();
8860 template<typename V> bool encode(size_t index, V& v) const
8862 if(index != type) {return false;} return v(ref_nested());
8872 CellReplacingInfo ::= SEQUENCE {
8873 replacingCellsList ReplacingCellsList,
8874 iE-Extensions ProtocolExtensionContainer { {CellReplacingInfo-ExtIEs}} OPTIONAL,
8879 struct CellReplacingInfo : asn::sequence<2, 0, true, 1>
8881 static constexpr const char* name() {return "CellReplacingInfo";}
8882 using parent_t = asn::sequence<2, 0, true, 1>;
8883 struct replacingCellsList_t : ReplacingCellsList
8885 static constexpr const char* name() {return "replacingCellsList_t";}
8886 using parent_t = ReplacingCellsList;
8889 replacingCellsList_t& ref_replacingCellsList() {return replacingCellsList;}
8890 replacingCellsList_t const& ref_replacingCellsList() const {return replacingCellsList;}
8891 struct iE_Extensions_t : ProtocolExtensionContainer<CellReplacingInfo_ExtIEs>
8893 static constexpr const char* name() {return "iE_Extensions_t";}
8894 using parent_t = ProtocolExtensionContainer<CellReplacingInfo_ExtIEs>;
8895 static constexpr bool optional = true;
8898 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
8899 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
8900 template<typename V> void decode(V& v)
8902 v(replacingCellsList);
8906 template<typename V> void encode(V& v) const
8908 v(replacingCellsList);
8914 replacingCellsList.clear();
8915 iE_Extensions.clear();
8919 replacingCellsList_t replacingCellsList;
8920 iE_Extensions_t iE_Extensions;
8924 CellReportingIndicator ::= ENUMERATED {stop-request, ... }
8927 struct CellReportingIndicator : asn::enumerated<1, 0, true>
8929 static constexpr const char* name() {return "CellReportingIndicator";}
8930 using parent_t = asn::enumerated<1, 0, true>;
8938 CellType-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
8943 struct CellType_ExtIEs
8945 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
8947 size_t get_index() const {return type;}
8948 bool is_unknown() const { return type == 1; }
8949 void clear() {type = 0;}
8950 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
8951 template<typename V> bool decode(V& v)
8954 if(!v(ref_nested())) return false;
8955 { type = 1; return true;}
8959 template<typename V> bool encode(V& v) const
8961 return v(ref_nested());
8965 template<typename V> bool decode(size_t index, V& v)
8970 case 1: type = 1; return v(ref_nested());
8971 ref_nested().clear();
8976 template<typename V> bool encode(size_t index, V& v) const
8978 if(index != type) {return false;} return v(ref_nested());
8985 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
8987 size_t get_index() const {return type;}
8988 bool is_unknown() const { return type == 1; }
8989 void clear() {type = 0;}
8990 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
8991 template<typename V> bool decode(V& v)
8994 if(!v(ref_nested())) return false;
8995 { type = 1; return true;}
8999 template<typename V> bool encode(V& v) const
9001 return v(ref_nested());
9005 template<typename V> bool decode(size_t index, V& v)
9010 case 1: type = 1; return v(ref_nested());
9011 ref_nested().clear();
9016 template<typename V> bool encode(size_t index, V& v) const
9018 if(index != type) {return false;} return v(ref_nested());
9025 struct Extension_t : asn::typefield<true>
9027 ~Extension_t() {clear();}
9028 size_t get_index() const {return type;}
9029 bool is_unknown() const { return type == 1; }
9032 type = 0; ref_nested().clear();
9034 template<typename V> static inline void enumerate(V& v)
9039 template<typename V> bool decode(size_t index, V& v)
9044 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9049 template<typename V> bool encode(size_t index, V& v) const
9051 if(index != type) return false;
9059 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9061 size_t get_index() const {return type;}
9062 bool is_unknown() const { return type == 1; }
9063 void clear() {type = 0;}
9064 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9065 template<typename V> bool decode(V& v)
9068 if(!v(ref_nested())) return false;
9069 { type = 1; return true;}
9073 template<typename V> bool encode(V& v) const
9075 return v(ref_nested());
9079 template<typename V> bool decode(size_t index, V& v)
9084 case 1: type = 1; return v(ref_nested());
9085 ref_nested().clear();
9090 template<typename V> bool encode(size_t index, V& v) const
9092 if(index != type) {return false;} return v(ref_nested());
9102 CellType ::= SEQUENCE {
9103 cell-Size Cell-Size,
9104 iE-Extensions ProtocolExtensionContainer { {CellType-ExtIEs}} OPTIONAL,
9109 struct CellType : asn::sequence<2, 0, true, 1>
9111 static constexpr const char* name() {return "CellType";}
9112 using parent_t = asn::sequence<2, 0, true, 1>;
9113 struct cell_Size_t : Cell_Size
9115 static constexpr const char* name() {return "cell_Size_t";}
9116 using parent_t = Cell_Size;
9119 cell_Size_t& ref_cell_Size() {return cell_Size;}
9120 cell_Size_t const& ref_cell_Size() const {return cell_Size;}
9121 struct iE_Extensions_t : ProtocolExtensionContainer<CellType_ExtIEs>
9123 static constexpr const char* name() {return "iE_Extensions_t";}
9124 using parent_t = ProtocolExtensionContainer<CellType_ExtIEs>;
9125 static constexpr bool optional = true;
9128 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9129 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9130 template<typename V> void decode(V& v)
9136 template<typename V> void encode(V& v) const
9145 iE_Extensions.clear();
9149 cell_Size_t cell_Size;
9150 iE_Extensions_t iE_Extensions;
9154 CoMPHypothesisSetItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9159 struct CoMPHypothesisSetItem_ExtIEs
9161 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9163 size_t get_index() const {return type;}
9164 bool is_unknown() const { return type == 1; }
9165 void clear() {type = 0;}
9166 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9167 template<typename V> bool decode(V& v)
9170 if(!v(ref_nested())) return false;
9171 { type = 1; return true;}
9175 template<typename V> bool encode(V& v) const
9177 return v(ref_nested());
9181 template<typename V> bool decode(size_t index, V& v)
9186 case 1: type = 1; return v(ref_nested());
9187 ref_nested().clear();
9192 template<typename V> bool encode(size_t index, V& v) const
9194 if(index != type) {return false;} return v(ref_nested());
9201 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9203 size_t get_index() const {return type;}
9204 bool is_unknown() const { return type == 1; }
9205 void clear() {type = 0;}
9206 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9207 template<typename V> bool decode(V& v)
9210 if(!v(ref_nested())) return false;
9211 { type = 1; return true;}
9215 template<typename V> bool encode(V& v) const
9217 return v(ref_nested());
9221 template<typename V> bool decode(size_t index, V& v)
9226 case 1: type = 1; return v(ref_nested());
9227 ref_nested().clear();
9232 template<typename V> bool encode(size_t index, V& v) const
9234 if(index != type) {return false;} return v(ref_nested());
9241 struct Extension_t : asn::typefield<true>
9243 ~Extension_t() {clear();}
9244 size_t get_index() const {return type;}
9245 bool is_unknown() const { return type == 1; }
9248 type = 0; ref_nested().clear();
9250 template<typename V> static inline void enumerate(V& v)
9255 template<typename V> bool decode(size_t index, V& v)
9260 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9265 template<typename V> bool encode(size_t index, V& v) const
9267 if(index != type) return false;
9275 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9277 size_t get_index() const {return type;}
9278 bool is_unknown() const { return type == 1; }
9279 void clear() {type = 0;}
9280 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9281 template<typename V> bool decode(V& v)
9284 if(!v(ref_nested())) return false;
9285 { type = 1; return true;}
9289 template<typename V> bool encode(V& v) const
9291 return v(ref_nested());
9295 template<typename V> bool decode(size_t index, V& v)
9300 case 1: type = 1; return v(ref_nested());
9301 ref_nested().clear();
9306 template<typename V> bool encode(size_t index, V& v) const
9308 if(index != type) {return false;} return v(ref_nested());
9318 CoMPHypothesisSetItem ::= SEQUENCE {
9320 coMPHypothesis BIT STRING (SIZE(6..4400, ...)),
9321 iE-Extensions ProtocolExtensionContainer { {CoMPHypothesisSetItem-ExtIEs} } OPTIONAL,
9326 struct CoMPHypothesisSetItem : asn::sequence<3, 0, true, 1>
9328 static constexpr const char* name() {return "CoMPHypothesisSetItem";}
9329 using parent_t = asn::sequence<3, 0, true, 1>;
9330 struct coMPCellID_t : ECGI
9332 static constexpr const char* name() {return "coMPCellID_t";}
9333 using parent_t = ECGI;
9336 coMPCellID_t& ref_coMPCellID() {return coMPCellID;}
9337 coMPCellID_t const& ref_coMPCellID() const {return coMPCellID;}
9338 struct coMPHypothesis_t : asn::bstring<>
9340 using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
9341 static constexpr const char* name() {return "coMPHypothesis_t";}
9342 using parent_t = asn::bstring<>;
9346 coMPHypothesis_t& ref_coMPHypothesis() {return coMPHypothesis;}
9347 coMPHypothesis_t const& ref_coMPHypothesis() const {return coMPHypothesis;}
9348 struct iE_Extensions_t : ProtocolExtensionContainer<CoMPHypothesisSetItem_ExtIEs>
9350 static constexpr const char* name() {return "iE_Extensions_t";}
9351 using parent_t = ProtocolExtensionContainer<CoMPHypothesisSetItem_ExtIEs>;
9352 static constexpr bool optional = true;
9355 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9356 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9357 template<typename V> void decode(V& v)
9364 template<typename V> void encode(V& v) const
9374 coMPHypothesis.clear();
9375 iE_Extensions.clear();
9379 coMPCellID_t coMPCellID;
9380 coMPHypothesis_t coMPHypothesis;
9381 iE_Extensions_t iE_Extensions;
9385 CoMPHypothesisSet ::= SEQUENCE (SIZE(1..maxnoofCoMPCells)) OF CoMPHypothesisSetItem
9388 struct CoMPHypothesisSet_elm : CoMPHypothesisSetItem
9390 static constexpr const char* name() {return "CoMPHypothesisSet_elm";}
9391 using parent_t = CoMPHypothesisSetItem;
9394 struct CoMPHypothesisSet : asn::sequenceof<CoMPHypothesisSet_elm>
9396 static constexpr const char* name() {return "CoMPHypothesisSet";}
9397 using parent_t = asn::sequenceof<CoMPHypothesisSet_elm>;
9398 using constraint_t = asn::constraints<false,asn::span<1, maxnoofCoMPCells >>;
9402 CoMPInformationItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9407 struct CoMPInformationItem_ExtIEs
9409 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9411 size_t get_index() const {return type;}
9412 bool is_unknown() const { return type == 1; }
9413 void clear() {type = 0;}
9414 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9415 template<typename V> bool decode(V& v)
9418 if(!v(ref_nested())) return false;
9419 { type = 1; return true;}
9423 template<typename V> bool encode(V& v) const
9425 return v(ref_nested());
9429 template<typename V> bool decode(size_t index, V& v)
9434 case 1: type = 1; return v(ref_nested());
9435 ref_nested().clear();
9440 template<typename V> bool encode(size_t index, V& v) const
9442 if(index != type) {return false;} return v(ref_nested());
9449 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9451 size_t get_index() const {return type;}
9452 bool is_unknown() const { return type == 1; }
9453 void clear() {type = 0;}
9454 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9455 template<typename V> bool decode(V& v)
9458 if(!v(ref_nested())) return false;
9459 { type = 1; return true;}
9463 template<typename V> bool encode(V& v) const
9465 return v(ref_nested());
9469 template<typename V> bool decode(size_t index, V& v)
9474 case 1: type = 1; return v(ref_nested());
9475 ref_nested().clear();
9480 template<typename V> bool encode(size_t index, V& v) const
9482 if(index != type) {return false;} return v(ref_nested());
9489 struct Extension_t : asn::typefield<true>
9491 ~Extension_t() {clear();}
9492 size_t get_index() const {return type;}
9493 bool is_unknown() const { return type == 1; }
9496 type = 0; ref_nested().clear();
9498 template<typename V> static inline void enumerate(V& v)
9503 template<typename V> bool decode(size_t index, V& v)
9508 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9513 template<typename V> bool encode(size_t index, V& v) const
9515 if(index != type) return false;
9523 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9525 size_t get_index() const {return type;}
9526 bool is_unknown() const { return type == 1; }
9527 void clear() {type = 0;}
9528 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9529 template<typename V> bool decode(V& v)
9532 if(!v(ref_nested())) return false;
9533 { type = 1; return true;}
9537 template<typename V> bool encode(V& v) const
9539 return v(ref_nested());
9543 template<typename V> bool decode(size_t index, V& v)
9548 case 1: type = 1; return v(ref_nested());
9549 ref_nested().clear();
9554 template<typename V> bool encode(size_t index, V& v) const
9556 if(index != type) {return false;} return v(ref_nested());
9566 CoMPInformationItem ::= SEQUENCE (SIZE(1..maxnoofCoMPHypothesisSet)) OF
9568 coMPHypothesisSet CoMPHypothesisSet,
9569 benefitMetric BenefitMetric,
9570 iE-Extensions ProtocolExtensionContainer { {CoMPInformationItem-ExtIEs} } OPTIONAL,
9575 struct CoMPInformationItem_elm : asn::sequence<3, 0, true, 1>
9577 static constexpr const char* name() {return "CoMPInformationItem_elm";}
9578 using parent_t = asn::sequence<3, 0, true, 1>;
9579 struct coMPHypothesisSet_t : CoMPHypothesisSet
9581 static constexpr const char* name() {return "coMPHypothesisSet_t";}
9582 using parent_t = CoMPHypothesisSet;
9585 coMPHypothesisSet_t& ref_coMPHypothesisSet() {return coMPHypothesisSet;}
9586 coMPHypothesisSet_t const& ref_coMPHypothesisSet() const {return coMPHypothesisSet;}
9587 struct benefitMetric_t : BenefitMetric
9589 static constexpr const char* name() {return "benefitMetric_t";}
9590 using parent_t = BenefitMetric;
9593 benefitMetric_t& ref_benefitMetric() {return benefitMetric;}
9594 benefitMetric_t const& ref_benefitMetric() const {return benefitMetric;}
9595 struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformationItem_ExtIEs>
9597 static constexpr const char* name() {return "iE_Extensions_t";}
9598 using parent_t = ProtocolExtensionContainer<CoMPInformationItem_ExtIEs>;
9599 static constexpr bool optional = true;
9602 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9603 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9604 template<typename V> void decode(V& v)
9606 v(coMPHypothesisSet);
9611 template<typename V> void encode(V& v) const
9613 v(coMPHypothesisSet);
9620 coMPHypothesisSet.clear();
9621 benefitMetric.clear();
9622 iE_Extensions.clear();
9626 coMPHypothesisSet_t coMPHypothesisSet;
9627 benefitMetric_t benefitMetric;
9628 iE_Extensions_t iE_Extensions;
9631 struct CoMPInformationItem : asn::sequenceof<CoMPInformationItem_elm>
9633 static constexpr const char* name() {return "CoMPInformationItem";}
9634 using parent_t = asn::sequenceof<CoMPInformationItem_elm>;
9635 using constraint_t = asn::constraints<false,asn::span<1, maxnoofCoMPHypothesisSet >>;
9639 CoMPInformationStartTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9644 struct CoMPInformationStartTime_ExtIEs
9646 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9648 size_t get_index() const {return type;}
9649 bool is_unknown() const { return type == 1; }
9650 void clear() {type = 0;}
9651 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9652 template<typename V> bool decode(V& v)
9655 if(!v(ref_nested())) return false;
9656 { type = 1; return true;}
9660 template<typename V> bool encode(V& v) const
9662 return v(ref_nested());
9666 template<typename V> bool decode(size_t index, V& v)
9671 case 1: type = 1; return v(ref_nested());
9672 ref_nested().clear();
9677 template<typename V> bool encode(size_t index, V& v) const
9679 if(index != type) {return false;} return v(ref_nested());
9686 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9688 size_t get_index() const {return type;}
9689 bool is_unknown() const { return type == 1; }
9690 void clear() {type = 0;}
9691 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9692 template<typename V> bool decode(V& v)
9695 if(!v(ref_nested())) return false;
9696 { type = 1; return true;}
9700 template<typename V> bool encode(V& v) const
9702 return v(ref_nested());
9706 template<typename V> bool decode(size_t index, V& v)
9711 case 1: type = 1; return v(ref_nested());
9712 ref_nested().clear();
9717 template<typename V> bool encode(size_t index, V& v) const
9719 if(index != type) {return false;} return v(ref_nested());
9726 struct Extension_t : asn::typefield<true>
9728 ~Extension_t() {clear();}
9729 size_t get_index() const {return type;}
9730 bool is_unknown() const { return type == 1; }
9733 type = 0; ref_nested().clear();
9735 template<typename V> static inline void enumerate(V& v)
9740 template<typename V> bool decode(size_t index, V& v)
9745 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9750 template<typename V> bool encode(size_t index, V& v) const
9752 if(index != type) return false;
9760 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
9762 size_t get_index() const {return type;}
9763 bool is_unknown() const { return type == 1; }
9764 void clear() {type = 0;}
9765 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
9766 template<typename V> bool decode(V& v)
9769 if(!v(ref_nested())) return false;
9770 { type = 1; return true;}
9774 template<typename V> bool encode(V& v) const
9776 return v(ref_nested());
9780 template<typename V> bool decode(size_t index, V& v)
9785 case 1: type = 1; return v(ref_nested());
9786 ref_nested().clear();
9791 template<typename V> bool encode(size_t index, V& v) const
9793 if(index != type) {return false;} return v(ref_nested());
9803 CoMPInformationStartTime ::= SEQUENCE (SIZE(0..1)) OF
9805 startSFN INTEGER (0..1023, ...),
9806 startSubframeNumber INTEGER (0..9, ...),
9807 iE-Extensions ProtocolExtensionContainer { {CoMPInformationStartTime-ExtIEs} } OPTIONAL,
9812 struct CoMPInformationStartTime_elm : asn::sequence<3, 0, true, 1>
9814 static constexpr const char* name() {return "CoMPInformationStartTime_elm";}
9815 using parent_t = asn::sequence<3, 0, true, 1>;
9816 struct startSFN_t : asn::integer<>
9818 using constraint_t = asn::constraints<true,asn::span<0, 1023>>;
9819 static constexpr const char* name() {return "startSFN_t";}
9820 using parent_t = asn::integer<>;
9824 startSFN_t& ref_startSFN() {return startSFN;}
9825 startSFN_t const& ref_startSFN() const {return startSFN;}
9826 struct startSubframeNumber_t : asn::integer<>
9828 using constraint_t = asn::constraints<true,asn::span<0, 9>>;
9829 static constexpr const char* name() {return "startSubframeNumber_t";}
9830 using parent_t = asn::integer<>;
9834 startSubframeNumber_t& ref_startSubframeNumber() {return startSubframeNumber;}
9835 startSubframeNumber_t const& ref_startSubframeNumber() const {return startSubframeNumber;}
9836 struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformationStartTime_ExtIEs>
9838 static constexpr const char* name() {return "iE_Extensions_t";}
9839 using parent_t = ProtocolExtensionContainer<CoMPInformationStartTime_ExtIEs>;
9840 static constexpr bool optional = true;
9843 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
9844 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
9845 template<typename V> void decode(V& v)
9848 v(startSubframeNumber);
9852 template<typename V> void encode(V& v) const
9855 v(startSubframeNumber);
9862 startSubframeNumber.clear();
9863 iE_Extensions.clear();
9867 startSFN_t startSFN;
9868 startSubframeNumber_t startSubframeNumber;
9869 iE_Extensions_t iE_Extensions;
9872 struct CoMPInformationStartTime : asn::sequenceof<CoMPInformationStartTime_elm>
9874 static constexpr const char* name() {return "CoMPInformationStartTime";}
9875 using parent_t = asn::sequenceof<CoMPInformationStartTime_elm>;
9876 using constraint_t = asn::constraints<false,asn::span<0, 1>>;
9880 CoMPInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
9885 struct CoMPInformation_ExtIEs
9887 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
9889 size_t get_index() const {return type;}
9890 bool is_unknown() const { return type == 1; }
9891 void clear() {type = 0;}
9892 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
9893 template<typename V> bool decode(V& v)
9896 if(!v(ref_nested())) return false;
9897 { type = 1; return true;}
9901 template<typename V> bool encode(V& v) const
9903 return v(ref_nested());
9907 template<typename V> bool decode(size_t index, V& v)
9912 case 1: type = 1; return v(ref_nested());
9913 ref_nested().clear();
9918 template<typename V> bool encode(size_t index, V& v) const
9920 if(index != type) {return false;} return v(ref_nested());
9927 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
9929 size_t get_index() const {return type;}
9930 bool is_unknown() const { return type == 1; }
9931 void clear() {type = 0;}
9932 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
9933 template<typename V> bool decode(V& v)
9936 if(!v(ref_nested())) return false;
9937 { type = 1; return true;}
9941 template<typename V> bool encode(V& v) const
9943 return v(ref_nested());
9947 template<typename V> bool decode(size_t index, V& v)
9952 case 1: type = 1; return v(ref_nested());
9953 ref_nested().clear();
9958 template<typename V> bool encode(size_t index, V& v) const
9960 if(index != type) {return false;} return v(ref_nested());
9967 struct Extension_t : asn::typefield<true>
9969 ~Extension_t() {clear();}
9970 size_t get_index() const {return type;}
9971 bool is_unknown() const { return type == 1; }
9974 type = 0; ref_nested().clear();
9976 template<typename V> static inline void enumerate(V& v)
9981 template<typename V> bool decode(size_t index, V& v)
9986 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
9991 template<typename V> bool encode(size_t index, V& v) const
9993 if(index != type) return false;
10001 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10003 size_t get_index() const {return type;}
10004 bool is_unknown() const { return type == 1; }
10005 void clear() {type = 0;}
10006 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10007 template<typename V> bool decode(V& v)
10010 if(!v(ref_nested())) return false;
10011 { type = 1; return true;}
10015 template<typename V> bool encode(V& v) const
10017 return v(ref_nested());
10021 template<typename V> bool decode(size_t index, V& v)
10026 case 1: type = 1; return v(ref_nested());
10027 ref_nested().clear();
10032 template<typename V> bool encode(size_t index, V& v) const
10034 if(index != type) {return false;} return v(ref_nested());
10044 CoMPInformation ::= SEQUENCE {
10045 coMPInformationItem CoMPInformationItem,
10046 coMPInformationStartTime CoMPInformationStartTime,
10047 iE-Extensions ProtocolExtensionContainer { {CoMPInformation-ExtIEs} } OPTIONAL,
10052 struct CoMPInformation : asn::sequence<3, 0, true, 1>
10054 static constexpr const char* name() {return "CoMPInformation";}
10055 using parent_t = asn::sequence<3, 0, true, 1>;
10056 struct coMPInformationItem_t : CoMPInformationItem
10058 static constexpr const char* name() {return "coMPInformationItem_t";}
10059 using parent_t = CoMPInformationItem;
10062 coMPInformationItem_t& ref_coMPInformationItem() {return coMPInformationItem;}
10063 coMPInformationItem_t const& ref_coMPInformationItem() const {return coMPInformationItem;}
10064 struct coMPInformationStartTime_t : CoMPInformationStartTime
10066 static constexpr const char* name() {return "coMPInformationStartTime_t";}
10067 using parent_t = CoMPInformationStartTime;
10070 coMPInformationStartTime_t& ref_coMPInformationStartTime() {return coMPInformationStartTime;}
10071 coMPInformationStartTime_t const& ref_coMPInformationStartTime() const {return coMPInformationStartTime;}
10072 struct iE_Extensions_t : ProtocolExtensionContainer<CoMPInformation_ExtIEs>
10074 static constexpr const char* name() {return "iE_Extensions_t";}
10075 using parent_t = ProtocolExtensionContainer<CoMPInformation_ExtIEs>;
10076 static constexpr bool optional = true;
10079 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10080 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10081 template<typename V> void decode(V& v)
10083 v(coMPInformationItem);
10084 v(coMPInformationStartTime);
10088 template<typename V> void encode(V& v) const
10090 v(coMPInformationItem);
10091 v(coMPInformationStartTime);
10097 coMPInformationItem.clear();
10098 coMPInformationStartTime.clear();
10099 iE_Extensions.clear();
10103 coMPInformationItem_t coMPInformationItem;
10104 coMPInformationStartTime_t coMPInformationStartTime;
10105 iE_Extensions_t iE_Extensions;
10109 CompositeAvailableCapacity-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10114 struct CompositeAvailableCapacity_ExtIEs
10116 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10118 size_t get_index() const {return type;}
10119 bool is_unknown() const { return type == 1; }
10120 void clear() {type = 0;}
10121 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10122 template<typename V> bool decode(V& v)
10125 if(!v(ref_nested())) return false;
10126 { type = 1; return true;}
10130 template<typename V> bool encode(V& v) const
10132 return v(ref_nested());
10136 template<typename V> bool decode(size_t index, V& v)
10141 case 1: type = 1; return v(ref_nested());
10142 ref_nested().clear();
10147 template<typename V> bool encode(size_t index, V& v) const
10149 if(index != type) {return false;} return v(ref_nested());
10156 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10158 size_t get_index() const {return type;}
10159 bool is_unknown() const { return type == 1; }
10160 void clear() {type = 0;}
10161 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10162 template<typename V> bool decode(V& v)
10165 if(!v(ref_nested())) return false;
10166 { type = 1; return true;}
10170 template<typename V> bool encode(V& v) const
10172 return v(ref_nested());
10176 template<typename V> bool decode(size_t index, V& v)
10181 case 1: type = 1; return v(ref_nested());
10182 ref_nested().clear();
10187 template<typename V> bool encode(size_t index, V& v) const
10189 if(index != type) {return false;} return v(ref_nested());
10196 struct Extension_t : asn::typefield<true>
10198 ~Extension_t() {clear();}
10199 size_t get_index() const {return type;}
10200 bool is_unknown() const { return type == 1; }
10203 type = 0; ref_nested().clear();
10205 template<typename V> static inline void enumerate(V& v)
10210 template<typename V> bool decode(size_t index, V& v)
10215 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
10220 template<typename V> bool encode(size_t index, V& v) const
10222 if(index != type) return false;
10230 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10232 size_t get_index() const {return type;}
10233 bool is_unknown() const { return type == 1; }
10234 void clear() {type = 0;}
10235 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10236 template<typename V> bool decode(V& v)
10239 if(!v(ref_nested())) return false;
10240 { type = 1; return true;}
10244 template<typename V> bool encode(V& v) const
10246 return v(ref_nested());
10250 template<typename V> bool decode(size_t index, V& v)
10255 case 1: type = 1; return v(ref_nested());
10256 ref_nested().clear();
10261 template<typename V> bool encode(size_t index, V& v) const
10263 if(index != type) {return false;} return v(ref_nested());
10273 CompositeAvailableCapacity ::= SEQUENCE {
10274 cellCapacityClassValue CellCapacityClassValue OPTIONAL,
10275 capacityValue CapacityValue,
10276 iE-Extensions ProtocolExtensionContainer { {CompositeAvailableCapacity-ExtIEs} } OPTIONAL,
10281 struct CompositeAvailableCapacity : asn::sequence<3, 0, true, 2>
10283 static constexpr const char* name() {return "CompositeAvailableCapacity";}
10284 using parent_t = asn::sequence<3, 0, true, 2>;
10285 struct cellCapacityClassValue_t : CellCapacityClassValue
10287 static constexpr const char* name() {return "cellCapacityClassValue_t";}
10288 using parent_t = CellCapacityClassValue;
10289 static constexpr bool optional = true;
10292 cellCapacityClassValue_t& set_cellCapacityClassValue() { cellCapacityClassValue.setpresent(true); return cellCapacityClassValue;}
10293 cellCapacityClassValue_t const* get_cellCapacityClassValue() const {return cellCapacityClassValue.is_valid() ? &cellCapacityClassValue : nullptr;}
10294 struct capacityValue_t : CapacityValue
10296 static constexpr const char* name() {return "capacityValue_t";}
10297 using parent_t = CapacityValue;
10300 capacityValue_t& ref_capacityValue() {return capacityValue;}
10301 capacityValue_t const& ref_capacityValue() const {return capacityValue;}
10302 struct iE_Extensions_t : ProtocolExtensionContainer<CompositeAvailableCapacity_ExtIEs>
10304 static constexpr const char* name() {return "iE_Extensions_t";}
10305 using parent_t = ProtocolExtensionContainer<CompositeAvailableCapacity_ExtIEs>;
10306 static constexpr bool optional = true;
10309 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10310 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10311 template<typename V> void decode(V& v)
10313 v(cellCapacityClassValue);
10318 template<typename V> void encode(V& v) const
10320 v(cellCapacityClassValue);
10327 cellCapacityClassValue.clear();
10328 capacityValue.clear();
10329 iE_Extensions.clear();
10333 cellCapacityClassValue_t cellCapacityClassValue;
10334 capacityValue_t capacityValue;
10335 iE_Extensions_t iE_Extensions;
10339 CompositeAvailableCapacityGroup-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10344 struct CompositeAvailableCapacityGroup_ExtIEs
10346 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10348 size_t get_index() const {return type;}
10349 bool is_unknown() const { return type == 1; }
10350 void clear() {type = 0;}
10351 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10352 template<typename V> bool decode(V& v)
10355 if(!v(ref_nested())) return false;
10356 { type = 1; return true;}
10360 template<typename V> bool encode(V& v) const
10362 return v(ref_nested());
10366 template<typename V> bool decode(size_t index, V& v)
10371 case 1: type = 1; return v(ref_nested());
10372 ref_nested().clear();
10377 template<typename V> bool encode(size_t index, V& v) const
10379 if(index != type) {return false;} return v(ref_nested());
10386 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10388 size_t get_index() const {return type;}
10389 bool is_unknown() const { return type == 1; }
10390 void clear() {type = 0;}
10391 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10392 template<typename V> bool decode(V& v)
10395 if(!v(ref_nested())) return false;
10396 { type = 1; return true;}
10400 template<typename V> bool encode(V& v) const
10402 return v(ref_nested());
10406 template<typename V> bool decode(size_t index, V& v)
10411 case 1: type = 1; return v(ref_nested());
10412 ref_nested().clear();
10417 template<typename V> bool encode(size_t index, V& v) const
10419 if(index != type) {return false;} return v(ref_nested());
10426 struct Extension_t : asn::typefield<true>
10428 ~Extension_t() {clear();}
10429 size_t get_index() const {return type;}
10430 bool is_unknown() const { return type == 1; }
10433 type = 0; ref_nested().clear();
10435 template<typename V> static inline void enumerate(V& v)
10440 template<typename V> bool decode(size_t index, V& v)
10445 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
10450 template<typename V> bool encode(size_t index, V& v) const
10452 if(index != type) return false;
10460 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10462 size_t get_index() const {return type;}
10463 bool is_unknown() const { return type == 1; }
10464 void clear() {type = 0;}
10465 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10466 template<typename V> bool decode(V& v)
10469 if(!v(ref_nested())) return false;
10470 { type = 1; return true;}
10474 template<typename V> bool encode(V& v) const
10476 return v(ref_nested());
10480 template<typename V> bool decode(size_t index, V& v)
10485 case 1: type = 1; return v(ref_nested());
10486 ref_nested().clear();
10491 template<typename V> bool encode(size_t index, V& v) const
10493 if(index != type) {return false;} return v(ref_nested());
10503 CompositeAvailableCapacityGroup ::= SEQUENCE {
10504 dL-CompositeAvailableCapacity CompositeAvailableCapacity,
10505 uL-CompositeAvailableCapacity CompositeAvailableCapacity,
10506 iE-Extensions ProtocolExtensionContainer { {CompositeAvailableCapacityGroup-ExtIEs} } OPTIONAL,
10511 struct CompositeAvailableCapacityGroup : asn::sequence<3, 0, true, 1>
10513 static constexpr const char* name() {return "CompositeAvailableCapacityGroup";}
10514 using parent_t = asn::sequence<3, 0, true, 1>;
10515 struct dL_CompositeAvailableCapacity_t : CompositeAvailableCapacity
10517 static constexpr const char* name() {return "dL_CompositeAvailableCapacity_t";}
10518 using parent_t = CompositeAvailableCapacity;
10521 dL_CompositeAvailableCapacity_t& ref_dL_CompositeAvailableCapacity() {return dL_CompositeAvailableCapacity;}
10522 dL_CompositeAvailableCapacity_t const& ref_dL_CompositeAvailableCapacity() const {return dL_CompositeAvailableCapacity;}
10523 struct uL_CompositeAvailableCapacity_t : CompositeAvailableCapacity
10525 static constexpr const char* name() {return "uL_CompositeAvailableCapacity_t";}
10526 using parent_t = CompositeAvailableCapacity;
10529 uL_CompositeAvailableCapacity_t& ref_uL_CompositeAvailableCapacity() {return uL_CompositeAvailableCapacity;}
10530 uL_CompositeAvailableCapacity_t const& ref_uL_CompositeAvailableCapacity() const {return uL_CompositeAvailableCapacity;}
10531 struct iE_Extensions_t : ProtocolExtensionContainer<CompositeAvailableCapacityGroup_ExtIEs>
10533 static constexpr const char* name() {return "iE_Extensions_t";}
10534 using parent_t = ProtocolExtensionContainer<CompositeAvailableCapacityGroup_ExtIEs>;
10535 static constexpr bool optional = true;
10538 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10539 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10540 template<typename V> void decode(V& v)
10542 v(dL_CompositeAvailableCapacity);
10543 v(uL_CompositeAvailableCapacity);
10547 template<typename V> void encode(V& v) const
10549 v(dL_CompositeAvailableCapacity);
10550 v(uL_CompositeAvailableCapacity);
10556 dL_CompositeAvailableCapacity.clear();
10557 uL_CompositeAvailableCapacity.clear();
10558 iE_Extensions.clear();
10562 dL_CompositeAvailableCapacity_t dL_CompositeAvailableCapacity;
10563 uL_CompositeAvailableCapacity_t uL_CompositeAvailableCapacity;
10564 iE_Extensions_t iE_Extensions;
10568 Correlation-ID ::= OCTET STRING (SIZE (4))
10571 struct Correlation_ID : asn::ostring<>
10573 using constraint_t = asn::constraints<false,asn::one<4>>;
10574 static constexpr const char* name() {return "Correlation-ID";}
10575 using parent_t = asn::ostring<>;
10580 CoverageModification-Item ::= SEQUENCE {
10582 coverageState INTEGER (0..15, ...),
10583 cellDeploymentStatusIndicator CellDeploymentStatusIndicator OPTIONAL,
10584 cellReplacingInfo CellReplacingInfo OPTIONAL,
10585 -- Included in case the Cell Deployment Status Indicator IE is present
10590 struct CoverageModification_Item : asn::sequence<4, 0, true, 2>
10592 static constexpr const char* name() {return "CoverageModification-Item";}
10593 using parent_t = asn::sequence<4, 0, true, 2>;
10594 struct eCGI_t : ECGI
10596 static constexpr const char* name() {return "eCGI_t";}
10597 using parent_t = ECGI;
10600 eCGI_t& ref_eCGI() {return eCGI;}
10601 eCGI_t const& ref_eCGI() const {return eCGI;}
10602 struct coverageState_t : asn::integer<>
10604 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
10605 static constexpr const char* name() {return "coverageState_t";}
10606 using parent_t = asn::integer<>;
10610 coverageState_t& ref_coverageState() {return coverageState;}
10611 coverageState_t const& ref_coverageState() const {return coverageState;}
10612 struct cellDeploymentStatusIndicator_t : CellDeploymentStatusIndicator
10614 static constexpr const char* name() {return "cellDeploymentStatusIndicator_t";}
10615 using parent_t = CellDeploymentStatusIndicator;
10616 static constexpr bool optional = true;
10619 cellDeploymentStatusIndicator_t& set_cellDeploymentStatusIndicator() { cellDeploymentStatusIndicator.setpresent(true); return cellDeploymentStatusIndicator;}
10620 cellDeploymentStatusIndicator_t const* get_cellDeploymentStatusIndicator() const {return cellDeploymentStatusIndicator.is_valid() ? &cellDeploymentStatusIndicator : nullptr;}
10621 struct cellReplacingInfo_t : CellReplacingInfo
10623 static constexpr const char* name() {return "cellReplacingInfo_t";}
10624 using parent_t = CellReplacingInfo;
10625 static constexpr bool optional = true;
10628 cellReplacingInfo_t& set_cellReplacingInfo() { cellReplacingInfo.setpresent(true); return cellReplacingInfo;}
10629 cellReplacingInfo_t const* get_cellReplacingInfo() const {return cellReplacingInfo.is_valid() ? &cellReplacingInfo : nullptr;}
10630 template<typename V> void decode(V& v)
10634 v(cellDeploymentStatusIndicator);
10635 v(cellReplacingInfo);
10638 template<typename V> void encode(V& v) const
10642 v(cellDeploymentStatusIndicator);
10643 v(cellReplacingInfo);
10649 coverageState.clear();
10650 cellDeploymentStatusIndicator.clear();
10651 cellReplacingInfo.clear();
10656 coverageState_t coverageState;
10657 cellDeploymentStatusIndicator_t cellDeploymentStatusIndicator;
10658 cellReplacingInfo_t cellReplacingInfo;
10662 CoverageModificationList ::= SEQUENCE (SIZE (1..maxCellineNB)) OF CoverageModification-Item
10665 struct CoverageModificationList_elm : CoverageModification_Item
10667 static constexpr const char* name() {return "CoverageModificationList_elm";}
10668 using parent_t = CoverageModification_Item;
10671 struct CoverageModificationList : asn::sequenceof<CoverageModificationList_elm>
10673 static constexpr const char* name() {return "CoverageModificationList";}
10674 using parent_t = asn::sequenceof<CoverageModificationList_elm>;
10675 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
10679 TypeOfError ::= ENUMERATED {
10686 struct TypeOfError : asn::enumerated<2, 0, true>
10688 static constexpr const char* name() {return "TypeOfError";}
10689 using parent_t = asn::enumerated<2, 0, true>;
10698 CriticalityDiagnostics-IE-List-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10703 struct CriticalityDiagnostics_IE_List_ExtIEs
10705 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10707 size_t get_index() const {return type;}
10708 bool is_unknown() const { return type == 1; }
10709 void clear() {type = 0;}
10710 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10711 template<typename V> bool decode(V& v)
10714 if(!v(ref_nested())) return false;
10715 { type = 1; return true;}
10719 template<typename V> bool encode(V& v) const
10721 return v(ref_nested());
10725 template<typename V> bool decode(size_t index, V& v)
10730 case 1: type = 1; return v(ref_nested());
10731 ref_nested().clear();
10736 template<typename V> bool encode(size_t index, V& v) const
10738 if(index != type) {return false;} return v(ref_nested());
10745 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10747 size_t get_index() const {return type;}
10748 bool is_unknown() const { return type == 1; }
10749 void clear() {type = 0;}
10750 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
10751 template<typename V> bool decode(V& v)
10754 if(!v(ref_nested())) return false;
10755 { type = 1; return true;}
10759 template<typename V> bool encode(V& v) const
10761 return v(ref_nested());
10765 template<typename V> bool decode(size_t index, V& v)
10770 case 1: type = 1; return v(ref_nested());
10771 ref_nested().clear();
10776 template<typename V> bool encode(size_t index, V& v) const
10778 if(index != type) {return false;} return v(ref_nested());
10785 struct Extension_t : asn::typefield<true>
10787 ~Extension_t() {clear();}
10788 size_t get_index() const {return type;}
10789 bool is_unknown() const { return type == 1; }
10792 type = 0; ref_nested().clear();
10794 template<typename V> static inline void enumerate(V& v)
10799 template<typename V> bool decode(size_t index, V& v)
10804 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
10809 template<typename V> bool encode(size_t index, V& v) const
10811 if(index != type) return false;
10819 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
10821 size_t get_index() const {return type;}
10822 bool is_unknown() const { return type == 1; }
10823 void clear() {type = 0;}
10824 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
10825 template<typename V> bool decode(V& v)
10828 if(!v(ref_nested())) return false;
10829 { type = 1; return true;}
10833 template<typename V> bool encode(V& v) const
10835 return v(ref_nested());
10839 template<typename V> bool decode(size_t index, V& v)
10844 case 1: type = 1; return v(ref_nested());
10845 ref_nested().clear();
10850 template<typename V> bool encode(size_t index, V& v) const
10852 if(index != type) {return false;} return v(ref_nested());
10862 CriticalityDiagnostics-IE-List ::= SEQUENCE (SIZE (1..maxNrOfErrors)) OF
10864 iECriticality Criticality,
10865 iE-ID ProtocolIE-ID,
10866 typeOfError TypeOfError,
10867 iE-Extensions ProtocolExtensionContainer { {CriticalityDiagnostics-IE-List-ExtIEs} } OPTIONAL,
10872 struct CriticalityDiagnostics_IE_List_elm : asn::sequence<4, 0, true, 1>
10874 static constexpr const char* name() {return "CriticalityDiagnostics_IE_List_elm";}
10875 using parent_t = asn::sequence<4, 0, true, 1>;
10876 struct iECriticality_t : Criticality
10878 static constexpr const char* name() {return "iECriticality_t";}
10879 using parent_t = Criticality;
10882 iECriticality_t& ref_iECriticality() {return iECriticality;}
10883 iECriticality_t const& ref_iECriticality() const {return iECriticality;}
10884 struct iE_ID_t : ProtocolIE_ID
10886 static constexpr const char* name() {return "iE_ID_t";}
10887 using parent_t = ProtocolIE_ID;
10890 iE_ID_t& ref_iE_ID() {return iE_ID;}
10891 iE_ID_t const& ref_iE_ID() const {return iE_ID;}
10892 struct typeOfError_t : TypeOfError
10894 static constexpr const char* name() {return "typeOfError_t";}
10895 using parent_t = TypeOfError;
10898 typeOfError_t& ref_typeOfError() {return typeOfError;}
10899 typeOfError_t const& ref_typeOfError() const {return typeOfError;}
10900 struct iE_Extensions_t : ProtocolExtensionContainer<CriticalityDiagnostics_IE_List_ExtIEs>
10902 static constexpr const char* name() {return "iE_Extensions_t";}
10903 using parent_t = ProtocolExtensionContainer<CriticalityDiagnostics_IE_List_ExtIEs>;
10904 static constexpr bool optional = true;
10907 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
10908 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
10909 template<typename V> void decode(V& v)
10917 template<typename V> void encode(V& v) const
10927 iECriticality.clear();
10929 typeOfError.clear();
10930 iE_Extensions.clear();
10934 iECriticality_t iECriticality;
10936 typeOfError_t typeOfError;
10937 iE_Extensions_t iE_Extensions;
10940 struct CriticalityDiagnostics_IE_List : asn::sequenceof<CriticalityDiagnostics_IE_List_elm>
10942 static constexpr const char* name() {return "CriticalityDiagnostics-IE-List";}
10943 using parent_t = asn::sequenceof<CriticalityDiagnostics_IE_List_elm>;
10944 using constraint_t = asn::constraints<false,asn::span<1, maxNrOfErrors >>;
10948 CriticalityDiagnostics-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
10953 struct CriticalityDiagnostics_ExtIEs
10955 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
10957 size_t get_index() const {return type;}
10958 bool is_unknown() const { return type == 1; }
10959 void clear() {type = 0;}
10960 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
10961 template<typename V> bool decode(V& v)
10964 if(!v(ref_nested())) return false;
10965 { type = 1; return true;}
10969 template<typename V> bool encode(V& v) const
10971 return v(ref_nested());
10975 template<typename V> bool decode(size_t index, V& v)
10980 case 1: type = 1; return v(ref_nested());
10981 ref_nested().clear();
10986 template<typename V> bool encode(size_t index, V& v) const
10988 if(index != type) {return false;} return v(ref_nested());
10995 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
10997 size_t get_index() const {return type;}
10998 bool is_unknown() const { return type == 1; }
10999 void clear() {type = 0;}
11000 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11001 template<typename V> bool decode(V& v)
11004 if(!v(ref_nested())) return false;
11005 { type = 1; return true;}
11009 template<typename V> bool encode(V& v) const
11011 return v(ref_nested());
11015 template<typename V> bool decode(size_t index, V& v)
11020 case 1: type = 1; return v(ref_nested());
11021 ref_nested().clear();
11026 template<typename V> bool encode(size_t index, V& v) const
11028 if(index != type) {return false;} return v(ref_nested());
11035 struct Extension_t : asn::typefield<true>
11037 ~Extension_t() {clear();}
11038 size_t get_index() const {return type;}
11039 bool is_unknown() const { return type == 1; }
11042 type = 0; ref_nested().clear();
11044 template<typename V> static inline void enumerate(V& v)
11049 template<typename V> bool decode(size_t index, V& v)
11054 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11059 template<typename V> bool encode(size_t index, V& v) const
11061 if(index != type) return false;
11069 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11071 size_t get_index() const {return type;}
11072 bool is_unknown() const { return type == 1; }
11073 void clear() {type = 0;}
11074 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11075 template<typename V> bool decode(V& v)
11078 if(!v(ref_nested())) return false;
11079 { type = 1; return true;}
11083 template<typename V> bool encode(V& v) const
11085 return v(ref_nested());
11089 template<typename V> bool decode(size_t index, V& v)
11094 case 1: type = 1; return v(ref_nested());
11095 ref_nested().clear();
11100 template<typename V> bool encode(size_t index, V& v) const
11102 if(index != type) {return false;} return v(ref_nested());
11112 CriticalityDiagnostics ::= SEQUENCE {
11113 procedureCode ProcedureCode OPTIONAL,
11114 triggeringMessage TriggeringMessage OPTIONAL,
11115 procedureCriticality Criticality OPTIONAL,
11116 iEsCriticalityDiagnostics CriticalityDiagnostics-IE-List OPTIONAL,
11117 iE-Extensions ProtocolExtensionContainer { {CriticalityDiagnostics-ExtIEs} } OPTIONAL,
11122 struct CriticalityDiagnostics : asn::sequence<5, 0, true, 5>
11124 static constexpr const char* name() {return "CriticalityDiagnostics";}
11125 using parent_t = asn::sequence<5, 0, true, 5>;
11126 struct procedureCode_t : ProcedureCode
11128 static constexpr const char* name() {return "procedureCode_t";}
11129 using parent_t = ProcedureCode;
11130 static constexpr bool optional = true;
11133 procedureCode_t& set_procedureCode() { procedureCode.setpresent(true); return procedureCode;}
11134 procedureCode_t const* get_procedureCode() const {return procedureCode.is_valid() ? &procedureCode : nullptr;}
11135 struct triggeringMessage_t : TriggeringMessage
11137 static constexpr const char* name() {return "triggeringMessage_t";}
11138 using parent_t = TriggeringMessage;
11139 static constexpr bool optional = true;
11142 triggeringMessage_t& set_triggeringMessage() { triggeringMessage.setpresent(true); return triggeringMessage;}
11143 triggeringMessage_t const* get_triggeringMessage() const {return triggeringMessage.is_valid() ? &triggeringMessage : nullptr;}
11144 struct procedureCriticality_t : Criticality
11146 static constexpr const char* name() {return "procedureCriticality_t";}
11147 using parent_t = Criticality;
11148 static constexpr bool optional = true;
11151 procedureCriticality_t& set_procedureCriticality() { procedureCriticality.setpresent(true); return procedureCriticality;}
11152 procedureCriticality_t const* get_procedureCriticality() const {return procedureCriticality.is_valid() ? &procedureCriticality : nullptr;}
11153 struct iEsCriticalityDiagnostics_t : CriticalityDiagnostics_IE_List
11155 static constexpr const char* name() {return "iEsCriticalityDiagnostics_t";}
11156 using parent_t = CriticalityDiagnostics_IE_List;
11157 static constexpr bool optional = true;
11160 iEsCriticalityDiagnostics_t& set_iEsCriticalityDiagnostics() { iEsCriticalityDiagnostics.setpresent(true); return iEsCriticalityDiagnostics;}
11161 iEsCriticalityDiagnostics_t const* get_iEsCriticalityDiagnostics() const {return iEsCriticalityDiagnostics.is_valid() ? &iEsCriticalityDiagnostics : nullptr;}
11162 struct iE_Extensions_t : ProtocolExtensionContainer<CriticalityDiagnostics_ExtIEs>
11164 static constexpr const char* name() {return "iE_Extensions_t";}
11165 using parent_t = ProtocolExtensionContainer<CriticalityDiagnostics_ExtIEs>;
11166 static constexpr bool optional = true;
11169 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11170 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11171 template<typename V> void decode(V& v)
11174 v(triggeringMessage);
11175 v(procedureCriticality);
11176 v(iEsCriticalityDiagnostics);
11180 template<typename V> void encode(V& v) const
11183 v(triggeringMessage);
11184 v(procedureCriticality);
11185 v(iEsCriticalityDiagnostics);
11191 procedureCode.clear();
11192 triggeringMessage.clear();
11193 procedureCriticality.clear();
11194 iEsCriticalityDiagnostics.clear();
11195 iE_Extensions.clear();
11199 procedureCode_t procedureCode;
11200 triggeringMessage_t triggeringMessage;
11201 procedureCriticality_t procedureCriticality;
11202 iEsCriticalityDiagnostics_t iEsCriticalityDiagnostics;
11203 iE_Extensions_t iE_Extensions;
11207 DL-Forwarding ::= ENUMERATED {
11208 dL-forwardingProposed,
11213 struct DL_Forwarding : asn::enumerated<1, 0, true>
11215 static constexpr const char* name() {return "DL-Forwarding";}
11216 using parent_t = asn::enumerated<1, 0, true>;
11218 dL_forwardingProposed
11224 DL-GBR-PRB-usage::= INTEGER (0..100)
11227 struct DL_GBR_PRB_usage : asn::integer<>
11229 using constraint_t = asn::constraints<false,asn::span<0, 100>>;
11230 static constexpr const char* name() {return "DL-GBR-PRB-usage";}
11231 using parent_t = asn::integer<>;
11236 DL-Total-PRB-usage::= INTEGER (0..100)
11239 struct DL_Total_PRB_usage : asn::integer<>
11241 using constraint_t = asn::constraints<false,asn::span<0, 100>>;
11242 static constexpr const char* name() {return "DL-Total-PRB-usage";}
11243 using parent_t = asn::integer<>;
11248 DL-non-GBR-PRB-usage::= INTEGER (0..100)
11251 struct DL_non_GBR_PRB_usage : asn::integer<>
11253 using constraint_t = asn::constraints<false,asn::span<0, 100>>;
11254 static constexpr const char* name() {return "DL-non-GBR-PRB-usage";}
11255 using parent_t = asn::integer<>;
11260 DL-scheduling-PDCCH-CCE-usage::= INTEGER (0..100)
11263 struct DL_scheduling_PDCCH_CCE_usage : asn::integer<>
11265 using constraint_t = asn::constraints<false,asn::span<0, 100>>;
11266 static constexpr const char* name() {return "DL-scheduling-PDCCH-CCE-usage";}
11267 using parent_t = asn::integer<>;
11272 DataTrafficResources ::= BIT STRING (SIZE(6..17600))
11275 struct DataTrafficResources : asn::bstring<>
11277 using constraint_t = asn::constraints<false,asn::span<6, 17600>>;
11278 static constexpr const char* name() {return "DataTrafficResources";}
11279 using parent_t = asn::bstring<>;
11284 DLResourceBitmapULandDLSharing ::= DataTrafficResources
11287 struct DLResourceBitmapULandDLSharing : DataTrafficResources
11289 static constexpr const char* name() {return "DLResourceBitmapULandDLSharing";}
11290 using parent_t = DataTrafficResources;
11294 DLResourcesULandDLSharing ::= CHOICE {
11296 changed DLResourceBitmapULandDLSharing,
11301 struct DLResourcesULandDLSharing : asn::choice<2, 0, true>
11303 static constexpr const char* name() {return "DLResourcesULandDLSharing";}
11304 using parent_t = asn::choice<2, 0, true>;
11305 index_type get_index() const {return index;}
11306 bool is_unknown() const {return index == 3;}
11307 void set_unknown() { set_index(3); }
11308 ~DLResourcesULandDLSharing() {clear();}
11309 struct unchanged_t : asn::nulltype
11311 static constexpr const char* name() {return "unchanged_t";}
11312 using parent_t = asn::nulltype;
11315 struct changed_t : DLResourceBitmapULandDLSharing
11317 static constexpr const char* name() {return "changed_t";}
11318 using parent_t = DLResourceBitmapULandDLSharing;
11323 switch(get_index())
11325 case 1: var.destroy<unchanged_t>(); break;
11326 case 2: var.destroy<changed_t>(); break;
11331 template<typename V> bool decode(size_t idx, V& v)
11336 case 1: set_index(1); return v(var.build<unchanged_t>());
11337 case 2: set_index(2); return v(var.build<changed_t>());
11342 template<typename V> bool encode(V& v) const
11344 switch(get_index())
11346 case 1: return v(var.as<unchanged_t>());
11347 case 2: return v(var.as<changed_t>());
11351 template<typename V> static inline void enumerate(V& v)
11353 v.template operator()<unchanged_t>(1);
11354 v.template operator()<changed_t>(2);
11357 unchanged_t& select_unchanged() { if(get_index() != 1) { clear(); set_index(1); return var.build<unchanged_t>();} return var.as<unchanged_t>();}
11358 unchanged_t const* get_unchanged() const { if(get_index() == 1) { return &var.as<unchanged_t>();} return nullptr; }
11359 changed_t& select_changed() { if(get_index() != 2) { clear(); set_index(2); return var.build<changed_t>();} return var.as<changed_t>();}
11360 changed_t const* get_changed() const { if(get_index() == 2) { return &var.as<changed_t>();} return nullptr; }
11362 void set_index(index_type i) {index = i; base::set();}
11365 char dummy1[sizeof(unchanged_t)];
11366 char dummy2[sizeof(changed_t)];
11369 asn::variant<sizeof(union_type)> var;
11370 index_type index {0};
11373 DRB-ID ::= INTEGER (1..32)
11376 struct DRB_ID : asn::integer<>
11378 using constraint_t = asn::constraints<false,asn::span<1, 32>>;
11379 static constexpr const char* name() {return "DRB-ID";}
11380 using parent_t = asn::integer<>;
11385 ULOnlySharing-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
11390 struct ULOnlySharing_ExtIEs
11392 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
11394 size_t get_index() const {return type;}
11395 bool is_unknown() const { return type == 1; }
11396 void clear() {type = 0;}
11397 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
11398 template<typename V> bool decode(V& v)
11401 if(!v(ref_nested())) return false;
11402 { type = 1; return true;}
11406 template<typename V> bool encode(V& v) const
11408 return v(ref_nested());
11412 template<typename V> bool decode(size_t index, V& v)
11417 case 1: type = 1; return v(ref_nested());
11418 ref_nested().clear();
11423 template<typename V> bool encode(size_t index, V& v) const
11425 if(index != type) {return false;} return v(ref_nested());
11432 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
11434 size_t get_index() const {return type;}
11435 bool is_unknown() const { return type == 1; }
11436 void clear() {type = 0;}
11437 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11438 template<typename V> bool decode(V& v)
11441 if(!v(ref_nested())) return false;
11442 { type = 1; return true;}
11446 template<typename V> bool encode(V& v) const
11448 return v(ref_nested());
11452 template<typename V> bool decode(size_t index, V& v)
11457 case 1: type = 1; return v(ref_nested());
11458 ref_nested().clear();
11463 template<typename V> bool encode(size_t index, V& v) const
11465 if(index != type) {return false;} return v(ref_nested());
11472 struct Extension_t : asn::typefield<true>
11474 ~Extension_t() {clear();}
11475 size_t get_index() const {return type;}
11476 bool is_unknown() const { return type == 1; }
11479 type = 0; ref_nested().clear();
11481 template<typename V> static inline void enumerate(V& v)
11486 template<typename V> bool decode(size_t index, V& v)
11491 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11496 template<typename V> bool encode(size_t index, V& v) const
11498 if(index != type) return false;
11506 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11508 size_t get_index() const {return type;}
11509 bool is_unknown() const { return type == 1; }
11510 void clear() {type = 0;}
11511 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11512 template<typename V> bool decode(V& v)
11515 if(!v(ref_nested())) return false;
11516 { type = 1; return true;}
11520 template<typename V> bool encode(V& v) const
11522 return v(ref_nested());
11526 template<typename V> bool decode(size_t index, V& v)
11531 case 1: type = 1; return v(ref_nested());
11532 ref_nested().clear();
11537 template<typename V> bool encode(size_t index, V& v) const
11539 if(index != type) {return false;} return v(ref_nested());
11549 ULOnlySharing ::= SEQUENCE{
11550 uLResourceBitmapULOnlySharing DataTrafficResources,
11551 iE-Extensions ProtocolExtensionContainer { {ULOnlySharing-ExtIEs} } OPTIONAL,
11556 struct ULOnlySharing : asn::sequence<2, 0, true, 1>
11558 static constexpr const char* name() {return "ULOnlySharing";}
11559 using parent_t = asn::sequence<2, 0, true, 1>;
11560 struct uLResourceBitmapULOnlySharing_t : DataTrafficResources
11562 static constexpr const char* name() {return "uLResourceBitmapULOnlySharing_t";}
11563 using parent_t = DataTrafficResources;
11566 uLResourceBitmapULOnlySharing_t& ref_uLResourceBitmapULOnlySharing() {return uLResourceBitmapULOnlySharing;}
11567 uLResourceBitmapULOnlySharing_t const& ref_uLResourceBitmapULOnlySharing() const {return uLResourceBitmapULOnlySharing;}
11568 struct iE_Extensions_t : ProtocolExtensionContainer<ULOnlySharing_ExtIEs>
11570 static constexpr const char* name() {return "iE_Extensions_t";}
11571 using parent_t = ProtocolExtensionContainer<ULOnlySharing_ExtIEs>;
11572 static constexpr bool optional = true;
11575 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11576 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11577 template<typename V> void decode(V& v)
11579 v(uLResourceBitmapULOnlySharing);
11583 template<typename V> void encode(V& v) const
11585 v(uLResourceBitmapULOnlySharing);
11591 uLResourceBitmapULOnlySharing.clear();
11592 iE_Extensions.clear();
11596 uLResourceBitmapULOnlySharing_t uLResourceBitmapULOnlySharing;
11597 iE_Extensions_t iE_Extensions;
11601 ULResourceBitmapULandDLSharing ::= DataTrafficResources
11604 struct ULResourceBitmapULandDLSharing : DataTrafficResources
11606 static constexpr const char* name() {return "ULResourceBitmapULandDLSharing";}
11607 using parent_t = DataTrafficResources;
11611 ULResourcesULandDLSharing ::= CHOICE {
11613 changed ULResourceBitmapULandDLSharing,
11618 struct ULResourcesULandDLSharing : asn::choice<2, 0, true>
11620 static constexpr const char* name() {return "ULResourcesULandDLSharing";}
11621 using parent_t = asn::choice<2, 0, true>;
11622 index_type get_index() const {return index;}
11623 bool is_unknown() const {return index == 3;}
11624 void set_unknown() { set_index(3); }
11625 ~ULResourcesULandDLSharing() {clear();}
11626 struct unchanged_t : asn::nulltype
11628 static constexpr const char* name() {return "unchanged_t";}
11629 using parent_t = asn::nulltype;
11632 struct changed_t : ULResourceBitmapULandDLSharing
11634 static constexpr const char* name() {return "changed_t";}
11635 using parent_t = ULResourceBitmapULandDLSharing;
11640 switch(get_index())
11642 case 1: var.destroy<unchanged_t>(); break;
11643 case 2: var.destroy<changed_t>(); break;
11648 template<typename V> bool decode(size_t idx, V& v)
11653 case 1: set_index(1); return v(var.build<unchanged_t>());
11654 case 2: set_index(2); return v(var.build<changed_t>());
11659 template<typename V> bool encode(V& v) const
11661 switch(get_index())
11663 case 1: return v(var.as<unchanged_t>());
11664 case 2: return v(var.as<changed_t>());
11668 template<typename V> static inline void enumerate(V& v)
11670 v.template operator()<unchanged_t>(1);
11671 v.template operator()<changed_t>(2);
11674 unchanged_t& select_unchanged() { if(get_index() != 1) { clear(); set_index(1); return var.build<unchanged_t>();} return var.as<unchanged_t>();}
11675 unchanged_t const* get_unchanged() const { if(get_index() == 1) { return &var.as<unchanged_t>();} return nullptr; }
11676 changed_t& select_changed() { if(get_index() != 2) { clear(); set_index(2); return var.build<changed_t>();} return var.as<changed_t>();}
11677 changed_t const* get_changed() const { if(get_index() == 2) { return &var.as<changed_t>();} return nullptr; }
11679 void set_index(index_type i) {index = i; base::set();}
11682 char dummy1[sizeof(unchanged_t)];
11683 char dummy2[sizeof(changed_t)];
11686 asn::variant<sizeof(union_type)> var;
11687 index_type index {0};
11690 ULandDLSharing-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
11695 struct ULandDLSharing_ExtIEs
11697 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
11699 size_t get_index() const {return type;}
11700 bool is_unknown() const { return type == 1; }
11701 void clear() {type = 0;}
11702 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
11703 template<typename V> bool decode(V& v)
11706 if(!v(ref_nested())) return false;
11707 { type = 1; return true;}
11711 template<typename V> bool encode(V& v) const
11713 return v(ref_nested());
11717 template<typename V> bool decode(size_t index, V& v)
11722 case 1: type = 1; return v(ref_nested());
11723 ref_nested().clear();
11728 template<typename V> bool encode(size_t index, V& v) const
11730 if(index != type) {return false;} return v(ref_nested());
11737 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
11739 size_t get_index() const {return type;}
11740 bool is_unknown() const { return type == 1; }
11741 void clear() {type = 0;}
11742 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
11743 template<typename V> bool decode(V& v)
11746 if(!v(ref_nested())) return false;
11747 { type = 1; return true;}
11751 template<typename V> bool encode(V& v) const
11753 return v(ref_nested());
11757 template<typename V> bool decode(size_t index, V& v)
11762 case 1: type = 1; return v(ref_nested());
11763 ref_nested().clear();
11768 template<typename V> bool encode(size_t index, V& v) const
11770 if(index != type) {return false;} return v(ref_nested());
11777 struct Extension_t : asn::typefield<true>
11779 ~Extension_t() {clear();}
11780 size_t get_index() const {return type;}
11781 bool is_unknown() const { return type == 1; }
11784 type = 0; ref_nested().clear();
11786 template<typename V> static inline void enumerate(V& v)
11791 template<typename V> bool decode(size_t index, V& v)
11796 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
11801 template<typename V> bool encode(size_t index, V& v) const
11803 if(index != type) return false;
11811 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
11813 size_t get_index() const {return type;}
11814 bool is_unknown() const { return type == 1; }
11815 void clear() {type = 0;}
11816 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
11817 template<typename V> bool decode(V& v)
11820 if(!v(ref_nested())) return false;
11821 { type = 1; return true;}
11825 template<typename V> bool encode(V& v) const
11827 return v(ref_nested());
11831 template<typename V> bool decode(size_t index, V& v)
11836 case 1: type = 1; return v(ref_nested());
11837 ref_nested().clear();
11842 template<typename V> bool encode(size_t index, V& v) const
11844 if(index != type) {return false;} return v(ref_nested());
11854 ULandDLSharing ::= SEQUENCE{
11855 uLResourcesULandDLSharing ULResourcesULandDLSharing,
11856 dLResourcesULandDLSharing DLResourcesULandDLSharing,
11857 iE-Extensions ProtocolExtensionContainer { {ULandDLSharing-ExtIEs} } OPTIONAL,
11862 struct ULandDLSharing : asn::sequence<3, 0, true, 1>
11864 static constexpr const char* name() {return "ULandDLSharing";}
11865 using parent_t = asn::sequence<3, 0, true, 1>;
11866 struct uLResourcesULandDLSharing_t : ULResourcesULandDLSharing
11868 static constexpr const char* name() {return "uLResourcesULandDLSharing_t";}
11869 using parent_t = ULResourcesULandDLSharing;
11872 uLResourcesULandDLSharing_t& ref_uLResourcesULandDLSharing() {return uLResourcesULandDLSharing;}
11873 uLResourcesULandDLSharing_t const& ref_uLResourcesULandDLSharing() const {return uLResourcesULandDLSharing;}
11874 struct dLResourcesULandDLSharing_t : DLResourcesULandDLSharing
11876 static constexpr const char* name() {return "dLResourcesULandDLSharing_t";}
11877 using parent_t = DLResourcesULandDLSharing;
11880 dLResourcesULandDLSharing_t& ref_dLResourcesULandDLSharing() {return dLResourcesULandDLSharing;}
11881 dLResourcesULandDLSharing_t const& ref_dLResourcesULandDLSharing() const {return dLResourcesULandDLSharing;}
11882 struct iE_Extensions_t : ProtocolExtensionContainer<ULandDLSharing_ExtIEs>
11884 static constexpr const char* name() {return "iE_Extensions_t";}
11885 using parent_t = ProtocolExtensionContainer<ULandDLSharing_ExtIEs>;
11886 static constexpr bool optional = true;
11889 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
11890 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
11891 template<typename V> void decode(V& v)
11893 v(uLResourcesULandDLSharing);
11894 v(dLResourcesULandDLSharing);
11898 template<typename V> void encode(V& v) const
11900 v(uLResourcesULandDLSharing);
11901 v(dLResourcesULandDLSharing);
11907 uLResourcesULandDLSharing.clear();
11908 dLResourcesULandDLSharing.clear();
11909 iE_Extensions.clear();
11913 uLResourcesULandDLSharing_t uLResourcesULandDLSharing;
11914 dLResourcesULandDLSharing_t dLResourcesULandDLSharing;
11915 iE_Extensions_t iE_Extensions;
11919 SharedResourceType ::= CHOICE{
11920 uLOnlySharing ULOnlySharing,
11921 uLandDLSharing ULandDLSharing,
11926 struct SharedResourceType : asn::choice<2, 0, true>
11928 static constexpr const char* name() {return "SharedResourceType";}
11929 using parent_t = asn::choice<2, 0, true>;
11930 index_type get_index() const {return index;}
11931 bool is_unknown() const {return index == 3;}
11932 void set_unknown() { set_index(3); }
11933 ~SharedResourceType() {clear();}
11934 struct uLOnlySharing_t : ULOnlySharing
11936 static constexpr const char* name() {return "uLOnlySharing_t";}
11937 using parent_t = ULOnlySharing;
11940 struct uLandDLSharing_t : ULandDLSharing
11942 static constexpr const char* name() {return "uLandDLSharing_t";}
11943 using parent_t = ULandDLSharing;
11948 switch(get_index())
11950 case 1: var.destroy<uLOnlySharing_t>(); break;
11951 case 2: var.destroy<uLandDLSharing_t>(); break;
11956 template<typename V> bool decode(size_t idx, V& v)
11961 case 1: set_index(1); return v(var.build<uLOnlySharing_t>());
11962 case 2: set_index(2); return v(var.build<uLandDLSharing_t>());
11967 template<typename V> bool encode(V& v) const
11969 switch(get_index())
11971 case 1: return v(var.as<uLOnlySharing_t>());
11972 case 2: return v(var.as<uLandDLSharing_t>());
11976 template<typename V> static inline void enumerate(V& v)
11978 v.template operator()<uLOnlySharing_t>(1);
11979 v.template operator()<uLandDLSharing_t>(2);
11982 uLOnlySharing_t& select_uLOnlySharing() { if(get_index() != 1) { clear(); set_index(1); return var.build<uLOnlySharing_t>();} return var.as<uLOnlySharing_t>();}
11983 uLOnlySharing_t const* get_uLOnlySharing() const { if(get_index() == 1) { return &var.as<uLOnlySharing_t>();} return nullptr; }
11984 uLandDLSharing_t& select_uLandDLSharing() { if(get_index() != 2) { clear(); set_index(2); return var.build<uLandDLSharing_t>();} return var.as<uLandDLSharing_t>();}
11985 uLandDLSharing_t const* get_uLandDLSharing() const { if(get_index() == 2) { return &var.as<uLandDLSharing_t>();} return nullptr; }
11987 void set_index(index_type i) {index = i; base::set();}
11990 char dummy1[sizeof(uLOnlySharing_t)];
11991 char dummy2[sizeof(uLandDLSharing_t)];
11994 asn::variant<sizeof(union_type)> var;
11995 index_type index {0};
11998 SubframeType ::= ENUMERATED{mbsfn,nonmbsfn,...}
12001 struct SubframeType : asn::enumerated<2, 0, true>
12003 static constexpr const char* name() {return "SubframeType";}
12004 using parent_t = asn::enumerated<2, 0, true>;
12013 ReservedSubframePattern-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12018 struct ReservedSubframePattern_ExtIEs
12020 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12022 size_t get_index() const {return type;}
12023 bool is_unknown() const { return type == 1; }
12024 void clear() {type = 0;}
12025 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12026 template<typename V> bool decode(V& v)
12029 if(!v(ref_nested())) return false;
12030 { type = 1; return true;}
12034 template<typename V> bool encode(V& v) const
12036 return v(ref_nested());
12040 template<typename V> bool decode(size_t index, V& v)
12045 case 1: type = 1; return v(ref_nested());
12046 ref_nested().clear();
12051 template<typename V> bool encode(size_t index, V& v) const
12053 if(index != type) {return false;} return v(ref_nested());
12060 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12062 size_t get_index() const {return type;}
12063 bool is_unknown() const { return type == 1; }
12064 void clear() {type = 0;}
12065 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12066 template<typename V> bool decode(V& v)
12069 if(!v(ref_nested())) return false;
12070 { type = 1; return true;}
12074 template<typename V> bool encode(V& v) const
12076 return v(ref_nested());
12080 template<typename V> bool decode(size_t index, V& v)
12085 case 1: type = 1; return v(ref_nested());
12086 ref_nested().clear();
12091 template<typename V> bool encode(size_t index, V& v) const
12093 if(index != type) {return false;} return v(ref_nested());
12100 struct Extension_t : asn::typefield<true>
12102 ~Extension_t() {clear();}
12103 size_t get_index() const {return type;}
12104 bool is_unknown() const { return type == 1; }
12107 type = 0; ref_nested().clear();
12109 template<typename V> static inline void enumerate(V& v)
12114 template<typename V> bool decode(size_t index, V& v)
12119 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12124 template<typename V> bool encode(size_t index, V& v) const
12126 if(index != type) return false;
12134 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12136 size_t get_index() const {return type;}
12137 bool is_unknown() const { return type == 1; }
12138 void clear() {type = 0;}
12139 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12140 template<typename V> bool decode(V& v)
12143 if(!v(ref_nested())) return false;
12144 { type = 1; return true;}
12148 template<typename V> bool encode(V& v) const
12150 return v(ref_nested());
12154 template<typename V> bool decode(size_t index, V& v)
12159 case 1: type = 1; return v(ref_nested());
12160 ref_nested().clear();
12165 template<typename V> bool encode(size_t index, V& v) const
12167 if(index != type) {return false;} return v(ref_nested());
12177 ReservedSubframePattern ::= SEQUENCE{
12178 subframeType SubframeType,
12179 reservedSubframePattern BIT STRING (SIZE(10..160)),
12180 mBSFNControlRegionLength INTEGER (0..3),
12181 iE-Extensions ProtocolExtensionContainer { {ReservedSubframePattern-ExtIEs} } OPTIONAL,
12186 struct ReservedSubframePattern : asn::sequence<4, 0, true, 1>
12188 static constexpr const char* name() {return "ReservedSubframePattern";}
12189 using parent_t = asn::sequence<4, 0, true, 1>;
12190 struct subframeType_t : SubframeType
12192 static constexpr const char* name() {return "subframeType_t";}
12193 using parent_t = SubframeType;
12196 subframeType_t& ref_subframeType() {return subframeType;}
12197 subframeType_t const& ref_subframeType() const {return subframeType;}
12198 struct reservedSubframePattern_t : asn::bstring<>
12200 using constraint_t = asn::constraints<false,asn::span<10, 160>>;
12201 static constexpr const char* name() {return "reservedSubframePattern_t";}
12202 using parent_t = asn::bstring<>;
12206 reservedSubframePattern_t& ref_reservedSubframePattern() {return reservedSubframePattern;}
12207 reservedSubframePattern_t const& ref_reservedSubframePattern() const {return reservedSubframePattern;}
12208 struct mBSFNControlRegionLength_t : asn::integer<>
12210 using constraint_t = asn::constraints<false,asn::span<0, 3>>;
12211 static constexpr const char* name() {return "mBSFNControlRegionLength_t";}
12212 using parent_t = asn::integer<>;
12216 mBSFNControlRegionLength_t& ref_mBSFNControlRegionLength() {return mBSFNControlRegionLength;}
12217 mBSFNControlRegionLength_t const& ref_mBSFNControlRegionLength() const {return mBSFNControlRegionLength;}
12218 struct iE_Extensions_t : ProtocolExtensionContainer<ReservedSubframePattern_ExtIEs>
12220 static constexpr const char* name() {return "iE_Extensions_t";}
12221 using parent_t = ProtocolExtensionContainer<ReservedSubframePattern_ExtIEs>;
12222 static constexpr bool optional = true;
12225 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12226 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12227 template<typename V> void decode(V& v)
12230 v(reservedSubframePattern);
12231 v(mBSFNControlRegionLength);
12235 template<typename V> void encode(V& v) const
12238 v(reservedSubframePattern);
12239 v(mBSFNControlRegionLength);
12245 subframeType.clear();
12246 reservedSubframePattern.clear();
12247 mBSFNControlRegionLength.clear();
12248 iE_Extensions.clear();
12252 subframeType_t subframeType;
12253 reservedSubframePattern_t reservedSubframePattern;
12254 mBSFNControlRegionLength_t mBSFNControlRegionLength;
12255 iE_Extensions_t iE_Extensions;
12259 DataTrafficResourceIndication-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12264 struct DataTrafficResourceIndication_ExtIEs
12266 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12268 size_t get_index() const {return type;}
12269 bool is_unknown() const { return type == 1; }
12270 void clear() {type = 0;}
12271 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12272 template<typename V> bool decode(V& v)
12275 if(!v(ref_nested())) return false;
12276 { type = 1; return true;}
12280 template<typename V> bool encode(V& v) const
12282 return v(ref_nested());
12286 template<typename V> bool decode(size_t index, V& v)
12291 case 1: type = 1; return v(ref_nested());
12292 ref_nested().clear();
12297 template<typename V> bool encode(size_t index, V& v) const
12299 if(index != type) {return false;} return v(ref_nested());
12306 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12308 size_t get_index() const {return type;}
12309 bool is_unknown() const { return type == 1; }
12310 void clear() {type = 0;}
12311 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12312 template<typename V> bool decode(V& v)
12315 if(!v(ref_nested())) return false;
12316 { type = 1; return true;}
12320 template<typename V> bool encode(V& v) const
12322 return v(ref_nested());
12326 template<typename V> bool decode(size_t index, V& v)
12331 case 1: type = 1; return v(ref_nested());
12332 ref_nested().clear();
12337 template<typename V> bool encode(size_t index, V& v) const
12339 if(index != type) {return false;} return v(ref_nested());
12346 struct Extension_t : asn::typefield<true>
12348 ~Extension_t() {clear();}
12349 size_t get_index() const {return type;}
12350 bool is_unknown() const { return type == 1; }
12353 type = 0; ref_nested().clear();
12355 template<typename V> static inline void enumerate(V& v)
12360 template<typename V> bool decode(size_t index, V& v)
12365 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12370 template<typename V> bool encode(size_t index, V& v) const
12372 if(index != type) return false;
12380 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12382 size_t get_index() const {return type;}
12383 bool is_unknown() const { return type == 1; }
12384 void clear() {type = 0;}
12385 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12386 template<typename V> bool decode(V& v)
12389 if(!v(ref_nested())) return false;
12390 { type = 1; return true;}
12394 template<typename V> bool encode(V& v) const
12396 return v(ref_nested());
12400 template<typename V> bool decode(size_t index, V& v)
12405 case 1: type = 1; return v(ref_nested());
12406 ref_nested().clear();
12411 template<typename V> bool encode(size_t index, V& v) const
12413 if(index != type) {return false;} return v(ref_nested());
12423 DataTrafficResourceIndication ::= SEQUENCE {
12424 activationSFN INTEGER (0..1023),
12425 sharedResourceType SharedResourceType,
12426 reservedSubframePattern ReservedSubframePattern OPTIONAL,
12427 iE-Extensions ProtocolExtensionContainer { {DataTrafficResourceIndication-ExtIEs} } OPTIONAL,
12432 struct DataTrafficResourceIndication : asn::sequence<4, 0, true, 2>
12434 static constexpr const char* name() {return "DataTrafficResourceIndication";}
12435 using parent_t = asn::sequence<4, 0, true, 2>;
12436 struct activationSFN_t : asn::integer<>
12438 using constraint_t = asn::constraints<false,asn::span<0, 1023>>;
12439 static constexpr const char* name() {return "activationSFN_t";}
12440 using parent_t = asn::integer<>;
12444 activationSFN_t& ref_activationSFN() {return activationSFN;}
12445 activationSFN_t const& ref_activationSFN() const {return activationSFN;}
12446 struct sharedResourceType_t : SharedResourceType
12448 static constexpr const char* name() {return "sharedResourceType_t";}
12449 using parent_t = SharedResourceType;
12452 sharedResourceType_t& ref_sharedResourceType() {return sharedResourceType;}
12453 sharedResourceType_t const& ref_sharedResourceType() const {return sharedResourceType;}
12454 struct reservedSubframePattern_t : ReservedSubframePattern
12456 static constexpr const char* name() {return "reservedSubframePattern_t";}
12457 using parent_t = ReservedSubframePattern;
12458 static constexpr bool optional = true;
12461 reservedSubframePattern_t& set_reservedSubframePattern() { reservedSubframePattern.setpresent(true); return reservedSubframePattern;}
12462 reservedSubframePattern_t const* get_reservedSubframePattern() const {return reservedSubframePattern.is_valid() ? &reservedSubframePattern : nullptr;}
12463 struct iE_Extensions_t : ProtocolExtensionContainer<DataTrafficResourceIndication_ExtIEs>
12465 static constexpr const char* name() {return "iE_Extensions_t";}
12466 using parent_t = ProtocolExtensionContainer<DataTrafficResourceIndication_ExtIEs>;
12467 static constexpr bool optional = true;
12470 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12471 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12472 template<typename V> void decode(V& v)
12475 v(sharedResourceType);
12476 v(reservedSubframePattern);
12480 template<typename V> void encode(V& v) const
12483 v(sharedResourceType);
12484 v(reservedSubframePattern);
12490 activationSFN.clear();
12491 sharedResourceType.clear();
12492 reservedSubframePattern.clear();
12493 iE_Extensions.clear();
12497 activationSFN_t activationSFN;
12498 sharedResourceType_t sharedResourceType;
12499 reservedSubframePattern_t reservedSubframePattern;
12500 iE_Extensions_t iE_Extensions;
12504 DeactivationIndication::= ENUMERATED {
12510 struct DeactivationIndication : asn::enumerated<1, 0, true>
12512 static constexpr const char* name() {return "DeactivationIndication";}
12513 using parent_t = asn::enumerated<1, 0, true>;
12521 DeliveryStatus-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12526 struct DeliveryStatus_ExtIEs
12528 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12530 size_t get_index() const {return type;}
12531 bool is_unknown() const { return type == 1; }
12532 void clear() {type = 0;}
12533 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12534 template<typename V> bool decode(V& v)
12537 if(!v(ref_nested())) return false;
12538 { type = 1; return true;}
12542 template<typename V> bool encode(V& v) const
12544 return v(ref_nested());
12548 template<typename V> bool decode(size_t index, V& v)
12553 case 1: type = 1; return v(ref_nested());
12554 ref_nested().clear();
12559 template<typename V> bool encode(size_t index, V& v) const
12561 if(index != type) {return false;} return v(ref_nested());
12568 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12570 size_t get_index() const {return type;}
12571 bool is_unknown() const { return type == 1; }
12572 void clear() {type = 0;}
12573 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12574 template<typename V> bool decode(V& v)
12577 if(!v(ref_nested())) return false;
12578 { type = 1; return true;}
12582 template<typename V> bool encode(V& v) const
12584 return v(ref_nested());
12588 template<typename V> bool decode(size_t index, V& v)
12593 case 1: type = 1; return v(ref_nested());
12594 ref_nested().clear();
12599 template<typename V> bool encode(size_t index, V& v) const
12601 if(index != type) {return false;} return v(ref_nested());
12608 struct Extension_t : asn::typefield<true>
12610 ~Extension_t() {clear();}
12611 size_t get_index() const {return type;}
12612 bool is_unknown() const { return type == 1; }
12615 type = 0; ref_nested().clear();
12617 template<typename V> static inline void enumerate(V& v)
12622 template<typename V> bool decode(size_t index, V& v)
12627 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12632 template<typename V> bool encode(size_t index, V& v) const
12634 if(index != type) return false;
12642 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12644 size_t get_index() const {return type;}
12645 bool is_unknown() const { return type == 1; }
12646 void clear() {type = 0;}
12647 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12648 template<typename V> bool decode(V& v)
12651 if(!v(ref_nested())) return false;
12652 { type = 1; return true;}
12656 template<typename V> bool encode(V& v) const
12658 return v(ref_nested());
12662 template<typename V> bool decode(size_t index, V& v)
12667 case 1: type = 1; return v(ref_nested());
12668 ref_nested().clear();
12673 template<typename V> bool encode(size_t index, V& v) const
12675 if(index != type) {return false;} return v(ref_nested());
12685 DeliveryStatus ::= SEQUENCE {
12686 highestSuccessDeliveredPDCPSN INTEGER (0..4095),
12687 iE-Extensions ProtocolExtensionContainer { {DeliveryStatus-ExtIEs} } OPTIONAL,
12692 struct DeliveryStatus : asn::sequence<2, 0, true, 1>
12694 static constexpr const char* name() {return "DeliveryStatus";}
12695 using parent_t = asn::sequence<2, 0, true, 1>;
12696 struct highestSuccessDeliveredPDCPSN_t : asn::integer<>
12698 using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
12699 static constexpr const char* name() {return "highestSuccessDeliveredPDCPSN_t";}
12700 using parent_t = asn::integer<>;
12704 highestSuccessDeliveredPDCPSN_t& ref_highestSuccessDeliveredPDCPSN() {return highestSuccessDeliveredPDCPSN;}
12705 highestSuccessDeliveredPDCPSN_t const& ref_highestSuccessDeliveredPDCPSN() const {return highestSuccessDeliveredPDCPSN;}
12706 struct iE_Extensions_t : ProtocolExtensionContainer<DeliveryStatus_ExtIEs>
12708 static constexpr const char* name() {return "iE_Extensions_t";}
12709 using parent_t = ProtocolExtensionContainer<DeliveryStatus_ExtIEs>;
12710 static constexpr bool optional = true;
12713 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
12714 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
12715 template<typename V> void decode(V& v)
12717 v(highestSuccessDeliveredPDCPSN);
12721 template<typename V> void encode(V& v) const
12723 v(highestSuccessDeliveredPDCPSN);
12729 highestSuccessDeliveredPDCPSN.clear();
12730 iE_Extensions.clear();
12734 highestSuccessDeliveredPDCPSN_t highestSuccessDeliveredPDCPSN;
12735 iE_Extensions_t iE_Extensions;
12739 DuplicationActivation::= ENUMERATED {active, inactive, ...}
12742 struct DuplicationActivation : asn::enumerated<2, 0, true>
12744 static constexpr const char* name() {return "DuplicationActivation";}
12745 using parent_t = asn::enumerated<2, 0, true>;
12754 PA-Values ::= ENUMERATED {
12767 struct PA_Values : asn::enumerated<8, 0, true>
12769 static constexpr const char* name() {return "PA-Values";}
12770 using parent_t = asn::enumerated<8, 0, true>;
12785 DynamicNAICSInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
12790 struct DynamicNAICSInformation_ExtIEs
12792 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
12794 size_t get_index() const {return type;}
12795 bool is_unknown() const { return type == 1; }
12796 void clear() {type = 0;}
12797 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
12798 template<typename V> bool decode(V& v)
12801 if(!v(ref_nested())) return false;
12802 { type = 1; return true;}
12806 template<typename V> bool encode(V& v) const
12808 return v(ref_nested());
12812 template<typename V> bool decode(size_t index, V& v)
12817 case 1: type = 1; return v(ref_nested());
12818 ref_nested().clear();
12823 template<typename V> bool encode(size_t index, V& v) const
12825 if(index != type) {return false;} return v(ref_nested());
12832 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
12834 size_t get_index() const {return type;}
12835 bool is_unknown() const { return type == 1; }
12836 void clear() {type = 0;}
12837 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
12838 template<typename V> bool decode(V& v)
12841 if(!v(ref_nested())) return false;
12842 { type = 1; return true;}
12846 template<typename V> bool encode(V& v) const
12848 return v(ref_nested());
12852 template<typename V> bool decode(size_t index, V& v)
12857 case 1: type = 1; return v(ref_nested());
12858 ref_nested().clear();
12863 template<typename V> bool encode(size_t index, V& v) const
12865 if(index != type) {return false;} return v(ref_nested());
12872 struct Extension_t : asn::typefield<true>
12874 ~Extension_t() {clear();}
12875 size_t get_index() const {return type;}
12876 bool is_unknown() const { return type == 1; }
12879 type = 0; ref_nested().clear();
12881 template<typename V> static inline void enumerate(V& v)
12886 template<typename V> bool decode(size_t index, V& v)
12891 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
12896 template<typename V> bool encode(size_t index, V& v) const
12898 if(index != type) return false;
12906 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
12908 size_t get_index() const {return type;}
12909 bool is_unknown() const { return type == 1; }
12910 void clear() {type = 0;}
12911 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
12912 template<typename V> bool decode(V& v)
12915 if(!v(ref_nested())) return false;
12916 { type = 1; return true;}
12920 template<typename V> bool encode(V& v) const
12922 return v(ref_nested());
12926 template<typename V> bool decode(size_t index, V& v)
12931 case 1: type = 1; return v(ref_nested());
12932 ref_nested().clear();
12937 template<typename V> bool encode(size_t index, V& v) const
12939 if(index != type) {return false;} return v(ref_nested());
12949 DynamicNAICSInformation ::= SEQUENCE {
12950 transmissionModes BIT STRING (SIZE(8)) OPTIONAL,
12951 pB-information INTEGER(0..3) OPTIONAL,
12952 pA-list SEQUENCE (SIZE(0..maxnoofPA)) OF PA-Values,
12953 iE-Extensions ProtocolExtensionContainer { {DynamicNAICSInformation-ExtIEs} } OPTIONAL,
12958 struct DynamicNAICSInformation : asn::sequence<4, 0, true, 3>
12960 static constexpr const char* name() {return "DynamicNAICSInformation";}
12961 using parent_t = asn::sequence<4, 0, true, 3>;
12962 struct transmissionModes_t : asn::bstring<>
12964 using constraint_t = asn::constraints<false,asn::one<8>>;
12965 static constexpr const char* name() {return "transmissionModes_t";}
12966 using parent_t = asn::bstring<>;
12967 static constexpr bool optional = true;
12971 transmissionModes_t& set_transmissionModes() { transmissionModes.setpresent(true); return transmissionModes;}
12972 transmissionModes_t const* get_transmissionModes() const {return transmissionModes.is_valid() ? &transmissionModes : nullptr;}
12973 struct pB_information_t : asn::integer<>
12975 using constraint_t = asn::constraints<false,asn::span<0, 3>>;
12976 static constexpr const char* name() {return "pB_information_t";}
12977 using parent_t = asn::integer<>;
12978 static constexpr bool optional = true;
12982 pB_information_t& set_pB_information() { pB_information.setpresent(true); return pB_information;}
12983 pB_information_t const* get_pB_information() const {return pB_information.is_valid() ? &pB_information : nullptr;}
12984 struct pA_list_t_elm : PA_Values
12986 static constexpr const char* name() {return "pA_list_t_elm";}
12987 using parent_t = PA_Values;
12990 struct pA_list_t : asn::sequenceof<pA_list_t_elm>
12992 static constexpr const char* name() {return "pA_list_t";}
12993 using parent_t = asn::sequenceof<pA_list_t_elm>;
12994 using constraint_t = asn::constraints<false,asn::span<0, maxnoofPA >>;
12997 pA_list_t& ref_pA_list() {return pA_list;}
12998 pA_list_t const& ref_pA_list() const {return pA_list;}
12999 struct iE_Extensions_t : ProtocolExtensionContainer<DynamicNAICSInformation_ExtIEs>
13001 static constexpr const char* name() {return "iE_Extensions_t";}
13002 using parent_t = ProtocolExtensionContainer<DynamicNAICSInformation_ExtIEs>;
13003 static constexpr bool optional = true;
13006 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13007 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13008 template<typename V> void decode(V& v)
13010 v(transmissionModes);
13016 template<typename V> void encode(V& v) const
13018 v(transmissionModes);
13026 transmissionModes.clear();
13027 pB_information.clear();
13029 iE_Extensions.clear();
13033 transmissionModes_t transmissionModes;
13034 pB_information_t pB_information;
13036 iE_Extensions_t iE_Extensions;
13040 DynamicDLTransmissionInformation ::= CHOICE {
13041 naics-active DynamicNAICSInformation,
13042 naics-inactive NULL,
13047 struct DynamicDLTransmissionInformation : asn::choice<2, 0, true>
13049 static constexpr const char* name() {return "DynamicDLTransmissionInformation";}
13050 using parent_t = asn::choice<2, 0, true>;
13051 index_type get_index() const {return index;}
13052 bool is_unknown() const {return index == 3;}
13053 void set_unknown() { set_index(3); }
13054 ~DynamicDLTransmissionInformation() {clear();}
13055 struct naics_active_t : DynamicNAICSInformation
13057 static constexpr const char* name() {return "naics_active_t";}
13058 using parent_t = DynamicNAICSInformation;
13061 struct naics_inactive_t : asn::nulltype
13063 static constexpr const char* name() {return "naics_inactive_t";}
13064 using parent_t = asn::nulltype;
13069 switch(get_index())
13071 case 1: var.destroy<naics_active_t>(); break;
13072 case 2: var.destroy<naics_inactive_t>(); break;
13077 template<typename V> bool decode(size_t idx, V& v)
13082 case 1: set_index(1); return v(var.build<naics_active_t>());
13083 case 2: set_index(2); return v(var.build<naics_inactive_t>());
13088 template<typename V> bool encode(V& v) const
13090 switch(get_index())
13092 case 1: return v(var.as<naics_active_t>());
13093 case 2: return v(var.as<naics_inactive_t>());
13097 template<typename V> static inline void enumerate(V& v)
13099 v.template operator()<naics_active_t>(1);
13100 v.template operator()<naics_inactive_t>(2);
13103 naics_active_t& select_naics_active() { if(get_index() != 1) { clear(); set_index(1); return var.build<naics_active_t>();} return var.as<naics_active_t>();}
13104 naics_active_t const* get_naics_active() const { if(get_index() == 1) { return &var.as<naics_active_t>();} return nullptr; }
13105 naics_inactive_t& select_naics_inactive() { if(get_index() != 2) { clear(); set_index(2); return var.build<naics_inactive_t>();} return var.as<naics_inactive_t>();}
13106 naics_inactive_t const* get_naics_inactive() const { if(get_index() == 2) { return &var.as<naics_inactive_t>();} return nullptr; }
13108 void set_index(index_type i) {index = i; base::set();}
13111 char dummy1[sizeof(naics_active_t)];
13112 char dummy2[sizeof(naics_inactive_t)];
13115 asn::variant<sizeof(union_type)> var;
13116 index_type index {0};
13119 E-RAB-ID ::= INTEGER (0..15, ...)
13122 struct E_RAB_ID : asn::integer<>
13124 using constraint_t = asn::constraints<true,asn::span<0, 15>>;
13125 static constexpr const char* name() {return "E-RAB-ID";}
13126 using parent_t = asn::integer<>;
13131 E-RAB-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13136 struct E_RAB_Item_ExtIEs
13138 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13140 size_t get_index() const {return type;}
13141 bool is_unknown() const { return type == 1; }
13142 void clear() {type = 0;}
13143 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13144 template<typename V> bool decode(V& v)
13147 if(!v(ref_nested())) return false;
13148 { type = 1; return true;}
13152 template<typename V> bool encode(V& v) const
13154 return v(ref_nested());
13158 template<typename V> bool decode(size_t index, V& v)
13163 case 1: type = 1; return v(ref_nested());
13164 ref_nested().clear();
13169 template<typename V> bool encode(size_t index, V& v) const
13171 if(index != type) {return false;} return v(ref_nested());
13178 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13180 size_t get_index() const {return type;}
13181 bool is_unknown() const { return type == 1; }
13182 void clear() {type = 0;}
13183 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13184 template<typename V> bool decode(V& v)
13187 if(!v(ref_nested())) return false;
13188 { type = 1; return true;}
13192 template<typename V> bool encode(V& v) const
13194 return v(ref_nested());
13198 template<typename V> bool decode(size_t index, V& v)
13203 case 1: type = 1; return v(ref_nested());
13204 ref_nested().clear();
13209 template<typename V> bool encode(size_t index, V& v) const
13211 if(index != type) {return false;} return v(ref_nested());
13218 struct Extension_t : asn::typefield<true>
13220 ~Extension_t() {clear();}
13221 size_t get_index() const {return type;}
13222 bool is_unknown() const { return type == 1; }
13225 type = 0; ref_nested().clear();
13227 template<typename V> static inline void enumerate(V& v)
13232 template<typename V> bool decode(size_t index, V& v)
13237 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
13242 template<typename V> bool encode(size_t index, V& v) const
13244 if(index != type) return false;
13252 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
13254 size_t get_index() const {return type;}
13255 bool is_unknown() const { return type == 1; }
13256 void clear() {type = 0;}
13257 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
13258 template<typename V> bool decode(V& v)
13261 if(!v(ref_nested())) return false;
13262 { type = 1; return true;}
13266 template<typename V> bool encode(V& v) const
13268 return v(ref_nested());
13272 template<typename V> bool decode(size_t index, V& v)
13277 case 1: type = 1; return v(ref_nested());
13278 ref_nested().clear();
13283 template<typename V> bool encode(size_t index, V& v) const
13285 if(index != type) {return false;} return v(ref_nested());
13295 E-RAB-Item ::= SEQUENCE {
13298 iE-Extensions ProtocolExtensionContainer { {E-RAB-Item-ExtIEs} } OPTIONAL,
13303 struct E_RAB_Item : asn::sequence<3, 0, true, 1>
13305 static constexpr const char* name() {return "E-RAB-Item";}
13306 using parent_t = asn::sequence<3, 0, true, 1>;
13307 struct e_RAB_ID_t : E_RAB_ID
13309 static constexpr const char* name() {return "e_RAB_ID_t";}
13310 using parent_t = E_RAB_ID;
13313 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
13314 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
13315 struct cause_t : Cause
13317 static constexpr const char* name() {return "cause_t";}
13318 using parent_t = Cause;
13321 cause_t& ref_cause() {return cause;}
13322 cause_t const& ref_cause() const {return cause;}
13323 struct iE_Extensions_t : ProtocolExtensionContainer<E_RAB_Item_ExtIEs>
13325 static constexpr const char* name() {return "iE_Extensions_t";}
13326 using parent_t = ProtocolExtensionContainer<E_RAB_Item_ExtIEs>;
13327 static constexpr bool optional = true;
13330 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13331 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13332 template<typename V> void decode(V& v)
13339 template<typename V> void encode(V& v) const
13350 iE_Extensions.clear();
13354 e_RAB_ID_t e_RAB_ID;
13356 iE_Extensions_t iE_Extensions;
13360 E-RAB-ItemIEs X2AP-PROTOCOL-IES ::= {
13361 { ID id-E-RAB-Item CRITICALITY ignore TYPE E-RAB-Item PRESENCE mandatory },
13366 struct E_RAB_ItemIEs
13368 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
13370 size_t get_index() const {return type;}
13371 bool is_unknown() const { return type == 2; }
13372 void clear() {type = 0;}
13373 void select_id_E_RAB_Item() { set(id_E_RAB_Item); type=1;}
13374 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
13375 template<typename V> bool decode(V& v)
13378 if(!v(ref_nested())) return false;
13379 if(equal(id_E_RAB_Item)) { type = 1; return true; }
13380 else { type = 2; return true;}
13384 template<typename V> bool encode(V& v) const
13386 return v(ref_nested());
13390 template<typename V> bool decode(size_t index, V& v)
13395 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RAB_Item);} return false;
13396 case 2: type = 2; return v(ref_nested());
13397 ref_nested().clear();
13402 template<typename V> bool encode(size_t index, V& v) const
13404 if(index != type) {return false;} return v(ref_nested());
13411 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
13413 size_t get_index() const {return type;}
13414 bool is_unknown() const { return type == 2; }
13415 void clear() {type = 0;}
13416 void select_id_E_RAB_Item() { set(ignore); type=1;}
13417 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
13418 template<typename V> bool decode(V& v)
13421 if(!v(ref_nested())) return false;
13422 if(equal(ignore)) { type = 1; return true; }
13423 else { type = 2; return true;}
13427 template<typename V> bool encode(V& v) const
13429 return v(ref_nested());
13433 template<typename V> bool decode(size_t index, V& v)
13438 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
13439 case 2: type = 2; return v(ref_nested());
13440 ref_nested().clear();
13445 template<typename V> bool encode(size_t index, V& v) const
13447 if(index != type) {return false;} return v(ref_nested());
13454 struct Value_t : asn::typefield<true>
13456 ~Value_t() {clear();}
13457 size_t get_index() const {return type;}
13458 E_RAB_Item& select_id_E_RAB_Item() { return set<E_RAB_Item>(1); }
13459 E_RAB_Item const* get_id_E_RAB_Item() const { return get<E_RAB_Item>(1); }
13460 bool is_unknown() const { return type == 2; }
13465 case 1: var.destroy<E_RAB_Item>(); break;
13467 type = 0; ref_nested().clear();
13469 template<typename V> static inline void enumerate(V& v)
13471 v.template operator()<E_RAB_Item>(1);
13475 template<typename V> bool decode(size_t index, V& v)
13480 case 1: v(select_id_E_RAB_Item()); return true;
13481 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
13486 template<typename V> bool encode(size_t index, V& v) const
13488 if(index != type) return false;
13491 case 1: v(var.as<E_RAB_Item>()); return true;
13497 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
13498 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
13501 char dummy1[sizeof(E_RAB_Item)];
13504 asn::variant<sizeof(union_type)> var;
13508 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
13510 size_t get_index() const {return type;}
13511 bool is_unknown() const { return type == 2; }
13512 void clear() {type = 0;}
13513 void select_id_E_RAB_Item() { set(mandatory); type=1;}
13514 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
13515 template<typename V> bool decode(V& v)
13518 if(!v(ref_nested())) return false;
13519 if(equal(mandatory)) { type = 1; return true; }
13520 else { type = 2; return true;}
13524 template<typename V> bool encode(V& v) const
13526 return v(ref_nested());
13530 template<typename V> bool decode(size_t index, V& v)
13535 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
13536 case 2: type = 2; return v(ref_nested());
13537 ref_nested().clear();
13542 template<typename V> bool encode(size_t index, V& v) const
13544 if(index != type) {return false;} return v(ref_nested());
13554 QCI ::= INTEGER (0..255)
13557 struct QCI : asn::integer<>
13559 using constraint_t = asn::constraints<false,asn::span<0, 255>>;
13560 static constexpr const char* name() {return "QCI";}
13561 using parent_t = asn::integer<>;
13566 ExtendedBitRate ::= INTEGER (10000000001..4000000000000,...)
13569 struct ExtendedBitRate : asn::integer<>
13571 using constraint_t = asn::constraints<true,asn::span<10000000001, 4000000000000>>;
13572 static constexpr const char* name() {return "ExtendedBitRate";}
13573 using parent_t = asn::integer<>;
13578 GBR-QosInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13579 -- Extension for maximum bitrate > 10Gbps --
13580 { ID id-extended-e-RAB-MaximumBitrateDL CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional}|
13581 { ID id-extended-e-RAB-MaximumBitrateUL CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional}|
13582 { ID id-extended-e-RAB-GuaranteedBitrateDL CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional}|
13583 { ID id-extended-e-RAB-GuaranteedBitrateUL CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional},
13588 struct GBR_QosInformation_ExtIEs
13590 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13592 size_t get_index() const {return type;}
13593 bool is_unknown() const { return type == 5; }
13594 void clear() {type = 0;}
13595 void select_id_extended_e_RAB_MaximumBitrateDL() { set(id_extended_e_RAB_MaximumBitrateDL); type=1;}
13596 void select_id_extended_e_RAB_MaximumBitrateUL() { set(id_extended_e_RAB_MaximumBitrateUL); type=2;}
13597 void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(id_extended_e_RAB_GuaranteedBitrateDL); type=3;}
13598 void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(id_extended_e_RAB_GuaranteedBitrateUL); type=4;}
13599 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13600 template<typename V> bool decode(V& v)
13603 if(!v(ref_nested())) return false;
13604 if(equal(id_extended_e_RAB_MaximumBitrateDL)) { type = 1; return true; }
13605 else if(equal(id_extended_e_RAB_MaximumBitrateUL)) { type = 2; return true; }
13606 else if(equal(id_extended_e_RAB_GuaranteedBitrateDL)) { type = 3; return true; }
13607 else if(equal(id_extended_e_RAB_GuaranteedBitrateUL)) { type = 4; return true; }
13608 else { type = 5; return true;}
13612 template<typename V> bool encode(V& v) const
13614 return v(ref_nested());
13618 template<typename V> bool decode(size_t index, V& v)
13623 case 1: type = 1; if(v(ref_nested())) { return equal(id_extended_e_RAB_MaximumBitrateDL);} return false;
13624 case 2: type = 2; if(v(ref_nested())) { return equal(id_extended_e_RAB_MaximumBitrateUL);} return false;
13625 case 3: type = 3; if(v(ref_nested())) { return equal(id_extended_e_RAB_GuaranteedBitrateDL);} return false;
13626 case 4: type = 4; if(v(ref_nested())) { return equal(id_extended_e_RAB_GuaranteedBitrateUL);} return false;
13627 case 5: type = 5; return v(ref_nested());
13628 ref_nested().clear();
13633 template<typename V> bool encode(size_t index, V& v) const
13635 if(index != type) {return false;} return v(ref_nested());
13642 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13644 size_t get_index() const {return type;}
13645 bool is_unknown() const { return type == 5; }
13646 void clear() {type = 0;}
13647 void select_id_extended_e_RAB_MaximumBitrateDL() { set(ignore); type=1;}
13648 void select_id_extended_e_RAB_MaximumBitrateUL() { set(ignore); type=2;}
13649 void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(ignore); type=3;}
13650 void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(ignore); type=4;}
13651 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13652 template<typename V> bool decode(V& v)
13655 if(!v(ref_nested())) return false;
13656 if(equal(ignore)) { type = 1; return true; }
13657 else if(equal(ignore)) { type = 2; return true; }
13658 else if(equal(ignore)) { type = 3; return true; }
13659 else if(equal(ignore)) { type = 4; return true; }
13660 else { type = 5; return true;}
13664 template<typename V> bool encode(V& v) const
13666 return v(ref_nested());
13670 template<typename V> bool decode(size_t index, V& v)
13675 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
13676 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
13677 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
13678 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
13679 case 5: type = 5; return v(ref_nested());
13680 ref_nested().clear();
13685 template<typename V> bool encode(size_t index, V& v) const
13687 if(index != type) {return false;} return v(ref_nested());
13694 struct Extension_t : asn::typefield<true>
13696 ~Extension_t() {clear();}
13697 size_t get_index() const {return type;}
13698 ExtendedBitRate& select_id_extended_e_RAB_MaximumBitrateDL() { return set<ExtendedBitRate>(1); }
13699 ExtendedBitRate const* get_id_extended_e_RAB_MaximumBitrateDL() const { return get<ExtendedBitRate>(1); }
13700 ExtendedBitRate& select_id_extended_e_RAB_MaximumBitrateUL() { return set<ExtendedBitRate>(2); }
13701 ExtendedBitRate const* get_id_extended_e_RAB_MaximumBitrateUL() const { return get<ExtendedBitRate>(2); }
13702 ExtendedBitRate& select_id_extended_e_RAB_GuaranteedBitrateDL() { return set<ExtendedBitRate>(3); }
13703 ExtendedBitRate const* get_id_extended_e_RAB_GuaranteedBitrateDL() const { return get<ExtendedBitRate>(3); }
13704 ExtendedBitRate& select_id_extended_e_RAB_GuaranteedBitrateUL() { return set<ExtendedBitRate>(4); }
13705 ExtendedBitRate const* get_id_extended_e_RAB_GuaranteedBitrateUL() const { return get<ExtendedBitRate>(4); }
13706 bool is_unknown() const { return type == 5; }
13711 case 1: var.destroy<ExtendedBitRate>(); break;
13712 case 2: var.destroy<ExtendedBitRate>(); break;
13713 case 3: var.destroy<ExtendedBitRate>(); break;
13714 case 4: var.destroy<ExtendedBitRate>(); break;
13716 type = 0; ref_nested().clear();
13718 template<typename V> static inline void enumerate(V& v)
13720 v.template operator()<ExtendedBitRate>(1);
13721 v.template operator()<ExtendedBitRate>(2);
13722 v.template operator()<ExtendedBitRate>(3);
13723 v.template operator()<ExtendedBitRate>(4);
13727 template<typename V> bool decode(size_t index, V& v)
13732 case 1: v(select_id_extended_e_RAB_MaximumBitrateDL()); return true;
13733 case 2: v(select_id_extended_e_RAB_MaximumBitrateUL()); return true;
13734 case 3: v(select_id_extended_e_RAB_GuaranteedBitrateDL()); return true;
13735 case 4: v(select_id_extended_e_RAB_GuaranteedBitrateUL()); return true;
13736 case 5: if(type != 5) {clear(); asn::base::set();} type = 5; return true;
13741 template<typename V> bool encode(size_t index, V& v) const
13743 if(index != type) return false;
13746 case 1: v(var.as<ExtendedBitRate>()); return true;
13747 case 2: v(var.as<ExtendedBitRate>()); return true;
13748 case 3: v(var.as<ExtendedBitRate>()); return true;
13749 case 4: v(var.as<ExtendedBitRate>()); return true;
13755 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
13756 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
13759 char dummy1[sizeof(ExtendedBitRate)];
13762 asn::variant<sizeof(union_type)> var;
13766 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
13768 size_t get_index() const {return type;}
13769 bool is_unknown() const { return type == 5; }
13770 void clear() {type = 0;}
13771 void select_id_extended_e_RAB_MaximumBitrateDL() { set(optional); type=1;}
13772 void select_id_extended_e_RAB_MaximumBitrateUL() { set(optional); type=2;}
13773 void select_id_extended_e_RAB_GuaranteedBitrateDL() { set(optional); type=3;}
13774 void select_id_extended_e_RAB_GuaranteedBitrateUL() { set(optional); type=4;}
13775 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
13776 template<typename V> bool decode(V& v)
13779 if(!v(ref_nested())) return false;
13780 if(equal(optional)) { type = 1; return true; }
13781 else if(equal(optional)) { type = 2; return true; }
13782 else if(equal(optional)) { type = 3; return true; }
13783 else if(equal(optional)) { type = 4; return true; }
13784 else { type = 5; return true;}
13788 template<typename V> bool encode(V& v) const
13790 return v(ref_nested());
13794 template<typename V> bool decode(size_t index, V& v)
13799 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
13800 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
13801 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
13802 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
13803 case 5: type = 5; return v(ref_nested());
13804 ref_nested().clear();
13809 template<typename V> bool encode(size_t index, V& v) const
13811 if(index != type) {return false;} return v(ref_nested());
13821 GBR-QosInformation ::= SEQUENCE {
13822 e-RAB-MaximumBitrateDL BitRate,
13823 e-RAB-MaximumBitrateUL BitRate,
13824 e-RAB-GuaranteedBitrateDL BitRate,
13825 e-RAB-GuaranteedBitrateUL BitRate,
13826 iE-Extensions ProtocolExtensionContainer { {GBR-QosInformation-ExtIEs} } OPTIONAL,
13831 struct GBR_QosInformation : asn::sequence<5, 0, true, 1>
13833 static constexpr const char* name() {return "GBR-QosInformation";}
13834 using parent_t = asn::sequence<5, 0, true, 1>;
13835 struct e_RAB_MaximumBitrateDL_t : BitRate
13837 static constexpr const char* name() {return "e_RAB_MaximumBitrateDL_t";}
13838 using parent_t = BitRate;
13841 e_RAB_MaximumBitrateDL_t& ref_e_RAB_MaximumBitrateDL() {return e_RAB_MaximumBitrateDL;}
13842 e_RAB_MaximumBitrateDL_t const& ref_e_RAB_MaximumBitrateDL() const {return e_RAB_MaximumBitrateDL;}
13843 struct e_RAB_MaximumBitrateUL_t : BitRate
13845 static constexpr const char* name() {return "e_RAB_MaximumBitrateUL_t";}
13846 using parent_t = BitRate;
13849 e_RAB_MaximumBitrateUL_t& ref_e_RAB_MaximumBitrateUL() {return e_RAB_MaximumBitrateUL;}
13850 e_RAB_MaximumBitrateUL_t const& ref_e_RAB_MaximumBitrateUL() const {return e_RAB_MaximumBitrateUL;}
13851 struct e_RAB_GuaranteedBitrateDL_t : BitRate
13853 static constexpr const char* name() {return "e_RAB_GuaranteedBitrateDL_t";}
13854 using parent_t = BitRate;
13857 e_RAB_GuaranteedBitrateDL_t& ref_e_RAB_GuaranteedBitrateDL() {return e_RAB_GuaranteedBitrateDL;}
13858 e_RAB_GuaranteedBitrateDL_t const& ref_e_RAB_GuaranteedBitrateDL() const {return e_RAB_GuaranteedBitrateDL;}
13859 struct e_RAB_GuaranteedBitrateUL_t : BitRate
13861 static constexpr const char* name() {return "e_RAB_GuaranteedBitrateUL_t";}
13862 using parent_t = BitRate;
13865 e_RAB_GuaranteedBitrateUL_t& ref_e_RAB_GuaranteedBitrateUL() {return e_RAB_GuaranteedBitrateUL;}
13866 e_RAB_GuaranteedBitrateUL_t const& ref_e_RAB_GuaranteedBitrateUL() const {return e_RAB_GuaranteedBitrateUL;}
13867 struct iE_Extensions_t : ProtocolExtensionContainer<GBR_QosInformation_ExtIEs>
13869 static constexpr const char* name() {return "iE_Extensions_t";}
13870 using parent_t = ProtocolExtensionContainer<GBR_QosInformation_ExtIEs>;
13871 static constexpr bool optional = true;
13874 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
13875 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
13876 template<typename V> void decode(V& v)
13878 v(e_RAB_MaximumBitrateDL);
13879 v(e_RAB_MaximumBitrateUL);
13880 v(e_RAB_GuaranteedBitrateDL);
13881 v(e_RAB_GuaranteedBitrateUL);
13885 template<typename V> void encode(V& v) const
13887 v(e_RAB_MaximumBitrateDL);
13888 v(e_RAB_MaximumBitrateUL);
13889 v(e_RAB_GuaranteedBitrateDL);
13890 v(e_RAB_GuaranteedBitrateUL);
13896 e_RAB_MaximumBitrateDL.clear();
13897 e_RAB_MaximumBitrateUL.clear();
13898 e_RAB_GuaranteedBitrateDL.clear();
13899 e_RAB_GuaranteedBitrateUL.clear();
13900 iE_Extensions.clear();
13904 e_RAB_MaximumBitrateDL_t e_RAB_MaximumBitrateDL;
13905 e_RAB_MaximumBitrateUL_t e_RAB_MaximumBitrateUL;
13906 e_RAB_GuaranteedBitrateDL_t e_RAB_GuaranteedBitrateDL;
13907 e_RAB_GuaranteedBitrateUL_t e_RAB_GuaranteedBitrateUL;
13908 iE_Extensions_t iE_Extensions;
13912 Packet-LossRate ::= INTEGER(0..1000)
13915 struct Packet_LossRate : asn::integer<>
13917 using constraint_t = asn::constraints<false,asn::span<0, 1000>>;
13918 static constexpr const char* name() {return "Packet-LossRate";}
13919 using parent_t = asn::integer<>;
13924 E-RAB-Level-QoS-Parameters-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
13925 -- Extended for introduction of downlink and uplink packet loss rate for enhanced Voice performance –
13926 { ID id-DownlinkPacketLossRate CRITICALITY ignore EXTENSION Packet-LossRate PRESENCE optional}|
13927 { ID id-UplinkPacketLossRate CRITICALITY ignore EXTENSION Packet-LossRate PRESENCE optional},
13932 struct E_RAB_Level_QoS_Parameters_ExtIEs
13934 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
13936 size_t get_index() const {return type;}
13937 bool is_unknown() const { return type == 3; }
13938 void clear() {type = 0;}
13939 void select_id_DownlinkPacketLossRate() { set(id_DownlinkPacketLossRate); type=1;}
13940 void select_id_UplinkPacketLossRate() { set(id_UplinkPacketLossRate); type=2;}
13941 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
13942 template<typename V> bool decode(V& v)
13945 if(!v(ref_nested())) return false;
13946 if(equal(id_DownlinkPacketLossRate)) { type = 1; return true; }
13947 else if(equal(id_UplinkPacketLossRate)) { type = 2; return true; }
13948 else { type = 3; return true;}
13952 template<typename V> bool encode(V& v) const
13954 return v(ref_nested());
13958 template<typename V> bool decode(size_t index, V& v)
13963 case 1: type = 1; if(v(ref_nested())) { return equal(id_DownlinkPacketLossRate);} return false;
13964 case 2: type = 2; if(v(ref_nested())) { return equal(id_UplinkPacketLossRate);} return false;
13965 case 3: type = 3; return v(ref_nested());
13966 ref_nested().clear();
13971 template<typename V> bool encode(size_t index, V& v) const
13973 if(index != type) {return false;} return v(ref_nested());
13980 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
13982 size_t get_index() const {return type;}
13983 bool is_unknown() const { return type == 3; }
13984 void clear() {type = 0;}
13985 void select_id_DownlinkPacketLossRate() { set(ignore); type=1;}
13986 void select_id_UplinkPacketLossRate() { set(ignore); type=2;}
13987 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
13988 template<typename V> bool decode(V& v)
13991 if(!v(ref_nested())) return false;
13992 if(equal(ignore)) { type = 1; return true; }
13993 else if(equal(ignore)) { type = 2; return true; }
13994 else { type = 3; return true;}
13998 template<typename V> bool encode(V& v) const
14000 return v(ref_nested());
14004 template<typename V> bool decode(size_t index, V& v)
14009 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
14010 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
14011 case 3: type = 3; return v(ref_nested());
14012 ref_nested().clear();
14017 template<typename V> bool encode(size_t index, V& v) const
14019 if(index != type) {return false;} return v(ref_nested());
14026 struct Extension_t : asn::typefield<true>
14028 ~Extension_t() {clear();}
14029 size_t get_index() const {return type;}
14030 Packet_LossRate& select_id_DownlinkPacketLossRate() { return set<Packet_LossRate>(1); }
14031 Packet_LossRate const* get_id_DownlinkPacketLossRate() const { return get<Packet_LossRate>(1); }
14032 Packet_LossRate& select_id_UplinkPacketLossRate() { return set<Packet_LossRate>(2); }
14033 Packet_LossRate const* get_id_UplinkPacketLossRate() const { return get<Packet_LossRate>(2); }
14034 bool is_unknown() const { return type == 3; }
14039 case 1: var.destroy<Packet_LossRate>(); break;
14040 case 2: var.destroy<Packet_LossRate>(); break;
14042 type = 0; ref_nested().clear();
14044 template<typename V> static inline void enumerate(V& v)
14046 v.template operator()<Packet_LossRate>(1);
14047 v.template operator()<Packet_LossRate>(2);
14051 template<typename V> bool decode(size_t index, V& v)
14056 case 1: v(select_id_DownlinkPacketLossRate()); return true;
14057 case 2: v(select_id_UplinkPacketLossRate()); return true;
14058 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
14063 template<typename V> bool encode(size_t index, V& v) const
14065 if(index != type) return false;
14068 case 1: v(var.as<Packet_LossRate>()); return true;
14069 case 2: v(var.as<Packet_LossRate>()); return true;
14075 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
14076 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
14079 char dummy1[sizeof(Packet_LossRate)];
14082 asn::variant<sizeof(union_type)> var;
14086 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
14088 size_t get_index() const {return type;}
14089 bool is_unknown() const { return type == 3; }
14090 void clear() {type = 0;}
14091 void select_id_DownlinkPacketLossRate() { set(optional); type=1;}
14092 void select_id_UplinkPacketLossRate() { set(optional); type=2;}
14093 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
14094 template<typename V> bool decode(V& v)
14097 if(!v(ref_nested())) return false;
14098 if(equal(optional)) { type = 1; return true; }
14099 else if(equal(optional)) { type = 2; return true; }
14100 else { type = 3; return true;}
14104 template<typename V> bool encode(V& v) const
14106 return v(ref_nested());
14110 template<typename V> bool decode(size_t index, V& v)
14115 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
14116 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
14117 case 3: type = 3; return v(ref_nested());
14118 ref_nested().clear();
14123 template<typename V> bool encode(size_t index, V& v) const
14125 if(index != type) {return false;} return v(ref_nested());
14135 E-RAB-Level-QoS-Parameters ::= SEQUENCE {
14137 allocationAndRetentionPriority AllocationAndRetentionPriority,
14138 gbrQosInformation GBR-QosInformation OPTIONAL,
14139 iE-Extensions ProtocolExtensionContainer { {E-RAB-Level-QoS-Parameters-ExtIEs} } OPTIONAL,
14144 struct E_RAB_Level_QoS_Parameters : asn::sequence<4, 0, true, 2>
14146 static constexpr const char* name() {return "E-RAB-Level-QoS-Parameters";}
14147 using parent_t = asn::sequence<4, 0, true, 2>;
14150 static constexpr const char* name() {return "qCI_t";}
14151 using parent_t = QCI;
14154 qCI_t& ref_qCI() {return qCI;}
14155 qCI_t const& ref_qCI() const {return qCI;}
14156 struct allocationAndRetentionPriority_t : AllocationAndRetentionPriority
14158 static constexpr const char* name() {return "allocationAndRetentionPriority_t";}
14159 using parent_t = AllocationAndRetentionPriority;
14162 allocationAndRetentionPriority_t& ref_allocationAndRetentionPriority() {return allocationAndRetentionPriority;}
14163 allocationAndRetentionPriority_t const& ref_allocationAndRetentionPriority() const {return allocationAndRetentionPriority;}
14164 struct gbrQosInformation_t : GBR_QosInformation
14166 static constexpr const char* name() {return "gbrQosInformation_t";}
14167 using parent_t = GBR_QosInformation;
14168 static constexpr bool optional = true;
14171 gbrQosInformation_t& set_gbrQosInformation() { gbrQosInformation.setpresent(true); return gbrQosInformation;}
14172 gbrQosInformation_t const* get_gbrQosInformation() const {return gbrQosInformation.is_valid() ? &gbrQosInformation : nullptr;}
14173 struct iE_Extensions_t : ProtocolExtensionContainer<E_RAB_Level_QoS_Parameters_ExtIEs>
14175 static constexpr const char* name() {return "iE_Extensions_t";}
14176 using parent_t = ProtocolExtensionContainer<E_RAB_Level_QoS_Parameters_ExtIEs>;
14177 static constexpr bool optional = true;
14180 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
14181 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
14182 template<typename V> void decode(V& v)
14185 v(allocationAndRetentionPriority);
14186 v(gbrQosInformation);
14190 template<typename V> void encode(V& v) const
14193 v(allocationAndRetentionPriority);
14194 v(gbrQosInformation);
14201 allocationAndRetentionPriority.clear();
14202 gbrQosInformation.clear();
14203 iE_Extensions.clear();
14208 allocationAndRetentionPriority_t allocationAndRetentionPriority;
14209 gbrQosInformation_t gbrQosInformation;
14210 iE_Extensions_t iE_Extensions;
14214 E-RAB-List ::= SEQUENCE (SIZE(1.. maxnoofBearers)) OF ProtocolIE-Single-Container { {E-RAB-ItemIEs} }
14217 struct E_RAB_List_elm : ProtocolIE_Single_Container<E_RAB_ItemIEs>
14219 static constexpr const char* name() {return "E_RAB_List_elm";}
14220 using parent_t = ProtocolIE_Single_Container<E_RAB_ItemIEs>;
14223 struct E_RAB_List : asn::sequenceof<E_RAB_List_elm>
14225 static constexpr const char* name() {return "E-RAB-List";}
14226 using parent_t = asn::sequenceof<E_RAB_List_elm>;
14227 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
14231 E-RABUsageReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
14236 struct E_RABUsageReport_Item_ExtIEs
14238 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
14240 size_t get_index() const {return type;}
14241 bool is_unknown() const { return type == 1; }
14242 void clear() {type = 0;}
14243 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
14244 template<typename V> bool decode(V& v)
14247 if(!v(ref_nested())) return false;
14248 { type = 1; return true;}
14252 template<typename V> bool encode(V& v) const
14254 return v(ref_nested());
14258 template<typename V> bool decode(size_t index, V& v)
14263 case 1: type = 1; return v(ref_nested());
14264 ref_nested().clear();
14269 template<typename V> bool encode(size_t index, V& v) const
14271 if(index != type) {return false;} return v(ref_nested());
14278 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
14280 size_t get_index() const {return type;}
14281 bool is_unknown() const { return type == 1; }
14282 void clear() {type = 0;}
14283 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
14284 template<typename V> bool decode(V& v)
14287 if(!v(ref_nested())) return false;
14288 { type = 1; return true;}
14292 template<typename V> bool encode(V& v) const
14294 return v(ref_nested());
14298 template<typename V> bool decode(size_t index, V& v)
14303 case 1: type = 1; return v(ref_nested());
14304 ref_nested().clear();
14309 template<typename V> bool encode(size_t index, V& v) const
14311 if(index != type) {return false;} return v(ref_nested());
14318 struct Extension_t : asn::typefield<true>
14320 ~Extension_t() {clear();}
14321 size_t get_index() const {return type;}
14322 bool is_unknown() const { return type == 1; }
14325 type = 0; ref_nested().clear();
14327 template<typename V> static inline void enumerate(V& v)
14332 template<typename V> bool decode(size_t index, V& v)
14337 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
14342 template<typename V> bool encode(size_t index, V& v) const
14344 if(index != type) return false;
14352 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
14354 size_t get_index() const {return type;}
14355 bool is_unknown() const { return type == 1; }
14356 void clear() {type = 0;}
14357 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
14358 template<typename V> bool decode(V& v)
14361 if(!v(ref_nested())) return false;
14362 { type = 1; return true;}
14366 template<typename V> bool encode(V& v) const
14368 return v(ref_nested());
14372 template<typename V> bool decode(size_t index, V& v)
14377 case 1: type = 1; return v(ref_nested());
14378 ref_nested().clear();
14383 template<typename V> bool encode(size_t index, V& v) const
14385 if(index != type) {return false;} return v(ref_nested());
14395 E-RABUsageReport-Item ::= SEQUENCE {
14396 startTimeStamp OCTET STRING (SIZE(4)),
14397 endTimeStamp OCTET STRING (SIZE(4)),
14398 usageCountUL INTEGER (0..4294967295),
14399 usageCountDL INTEGER (0..4294967295),
14400 iE-Extensions ProtocolExtensionContainer { {E-RABUsageReport-Item-ExtIEs} } OPTIONAL,
14405 struct E_RABUsageReport_Item : asn::sequence<5, 0, true, 1>
14407 static constexpr const char* name() {return "E-RABUsageReport-Item";}
14408 using parent_t = asn::sequence<5, 0, true, 1>;
14409 struct startTimeStamp_t : asn::ostring<>
14411 using constraint_t = asn::constraints<false,asn::one<4>>;
14412 static constexpr const char* name() {return "startTimeStamp_t";}
14413 using parent_t = asn::ostring<>;
14417 startTimeStamp_t& ref_startTimeStamp() {return startTimeStamp;}
14418 startTimeStamp_t const& ref_startTimeStamp() const {return startTimeStamp;}
14419 struct endTimeStamp_t : asn::ostring<>
14421 using constraint_t = asn::constraints<false,asn::one<4>>;
14422 static constexpr const char* name() {return "endTimeStamp_t";}
14423 using parent_t = asn::ostring<>;
14427 endTimeStamp_t& ref_endTimeStamp() {return endTimeStamp;}
14428 endTimeStamp_t const& ref_endTimeStamp() const {return endTimeStamp;}
14429 struct usageCountUL_t : asn::integer<>
14431 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14432 static constexpr const char* name() {return "usageCountUL_t";}
14433 using parent_t = asn::integer<>;
14437 usageCountUL_t& ref_usageCountUL() {return usageCountUL;}
14438 usageCountUL_t const& ref_usageCountUL() const {return usageCountUL;}
14439 struct usageCountDL_t : asn::integer<>
14441 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
14442 static constexpr const char* name() {return "usageCountDL_t";}
14443 using parent_t = asn::integer<>;
14447 usageCountDL_t& ref_usageCountDL() {return usageCountDL;}
14448 usageCountDL_t const& ref_usageCountDL() const {return usageCountDL;}
14449 struct iE_Extensions_t : ProtocolExtensionContainer<E_RABUsageReport_Item_ExtIEs>
14451 static constexpr const char* name() {return "iE_Extensions_t";}
14452 using parent_t = ProtocolExtensionContainer<E_RABUsageReport_Item_ExtIEs>;
14453 static constexpr bool optional = true;
14456 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
14457 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
14458 template<typename V> void decode(V& v)
14467 template<typename V> void encode(V& v) const
14478 startTimeStamp.clear();
14479 endTimeStamp.clear();
14480 usageCountUL.clear();
14481 usageCountDL.clear();
14482 iE_Extensions.clear();
14486 startTimeStamp_t startTimeStamp;
14487 endTimeStamp_t endTimeStamp;
14488 usageCountUL_t usageCountUL;
14489 usageCountDL_t usageCountDL;
14490 iE_Extensions_t iE_Extensions;
14494 E-RABUsageReport-ItemIEs X2AP-PROTOCOL-IES ::= {
14495 { ID id-E-RABUsageReport-Item CRITICALITY ignore TYPE E-RABUsageReport-Item PRESENCE mandatory },
14500 struct E_RABUsageReport_ItemIEs
14502 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
14504 size_t get_index() const {return type;}
14505 bool is_unknown() const { return type == 2; }
14506 void clear() {type = 0;}
14507 void select_id_E_RABUsageReport_Item() { set(id_E_RABUsageReport_Item); type=1;}
14508 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
14509 template<typename V> bool decode(V& v)
14512 if(!v(ref_nested())) return false;
14513 if(equal(id_E_RABUsageReport_Item)) { type = 1; return true; }
14514 else { type = 2; return true;}
14518 template<typename V> bool encode(V& v) const
14520 return v(ref_nested());
14524 template<typename V> bool decode(size_t index, V& v)
14529 case 1: type = 1; if(v(ref_nested())) { return equal(id_E_RABUsageReport_Item);} return false;
14530 case 2: type = 2; return v(ref_nested());
14531 ref_nested().clear();
14536 template<typename V> bool encode(size_t index, V& v) const
14538 if(index != type) {return false;} return v(ref_nested());
14545 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
14547 size_t get_index() const {return type;}
14548 bool is_unknown() const { return type == 2; }
14549 void clear() {type = 0;}
14550 void select_id_E_RABUsageReport_Item() { set(ignore); type=1;}
14551 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
14552 template<typename V> bool decode(V& v)
14555 if(!v(ref_nested())) return false;
14556 if(equal(ignore)) { type = 1; return true; }
14557 else { type = 2; return true;}
14561 template<typename V> bool encode(V& v) const
14563 return v(ref_nested());
14567 template<typename V> bool decode(size_t index, V& v)
14572 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
14573 case 2: type = 2; return v(ref_nested());
14574 ref_nested().clear();
14579 template<typename V> bool encode(size_t index, V& v) const
14581 if(index != type) {return false;} return v(ref_nested());
14588 struct Value_t : asn::typefield<true>
14590 ~Value_t() {clear();}
14591 size_t get_index() const {return type;}
14592 E_RABUsageReport_Item& select_id_E_RABUsageReport_Item() { return set<E_RABUsageReport_Item>(1); }
14593 E_RABUsageReport_Item const* get_id_E_RABUsageReport_Item() const { return get<E_RABUsageReport_Item>(1); }
14594 bool is_unknown() const { return type == 2; }
14599 case 1: var.destroy<E_RABUsageReport_Item>(); break;
14601 type = 0; ref_nested().clear();
14603 template<typename V> static inline void enumerate(V& v)
14605 v.template operator()<E_RABUsageReport_Item>(1);
14609 template<typename V> bool decode(size_t index, V& v)
14614 case 1: v(select_id_E_RABUsageReport_Item()); return true;
14615 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
14620 template<typename V> bool encode(size_t index, V& v) const
14622 if(index != type) return false;
14625 case 1: v(var.as<E_RABUsageReport_Item>()); return true;
14631 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
14632 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
14635 char dummy1[sizeof(E_RABUsageReport_Item)];
14638 asn::variant<sizeof(union_type)> var;
14642 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
14644 size_t get_index() const {return type;}
14645 bool is_unknown() const { return type == 2; }
14646 void clear() {type = 0;}
14647 void select_id_E_RABUsageReport_Item() { set(mandatory); type=1;}
14648 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
14649 template<typename V> bool decode(V& v)
14652 if(!v(ref_nested())) return false;
14653 if(equal(mandatory)) { type = 1; return true; }
14654 else { type = 2; return true;}
14658 template<typename V> bool encode(V& v) const
14660 return v(ref_nested());
14664 template<typename V> bool decode(size_t index, V& v)
14669 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
14670 case 2: type = 2; return v(ref_nested());
14671 ref_nested().clear();
14676 template<typename V> bool encode(size_t index, V& v) const
14678 if(index != type) {return false;} return v(ref_nested());
14688 E-RABUsageReportList ::= SEQUENCE (SIZE(1..maxnooftimeperiods)) OF ProtocolIE-Single-Container { {E-RABUsageReport-ItemIEs} }
14691 struct E_RABUsageReportList_elm : ProtocolIE_Single_Container<E_RABUsageReport_ItemIEs>
14693 static constexpr const char* name() {return "E_RABUsageReportList_elm";}
14694 using parent_t = ProtocolIE_Single_Container<E_RABUsageReport_ItemIEs>;
14697 struct E_RABUsageReportList : asn::sequenceof<E_RABUsageReportList_elm>
14699 static constexpr const char* name() {return "E-RABUsageReportList";}
14700 using parent_t = asn::sequenceof<E_RABUsageReportList_elm>;
14701 using constraint_t = asn::constraints<false,asn::span<1, maxnooftimeperiods >>;
14705 EARFCN ::= INTEGER (0..maxEARFCN)
14708 struct EARFCN : asn::integer<>
14710 using constraint_t = asn::constraints<false,asn::span<0, maxEARFCN >>;
14711 static constexpr const char* name() {return "EARFCN";}
14712 using parent_t = asn::integer<>;
14717 EARFCNExtension ::= INTEGER(maxEARFCNPlusOne..newmaxEARFCN, ...)
14720 struct EARFCNExtension : asn::integer<>
14722 using constraint_t = asn::constraints<true,asn::span< maxEARFCNPlusOne , newmaxEARFCN >>;
14723 static constexpr const char* name() {return "EARFCNExtension";}
14724 using parent_t = asn::integer<>;
14729 EN-DC-ResourceConfigurationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
14734 struct EN_DC_ResourceConfigurationExtIEs
14736 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
14738 size_t get_index() const {return type;}
14739 bool is_unknown() const { return type == 1; }
14740 void clear() {type = 0;}
14741 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
14742 template<typename V> bool decode(V& v)
14745 if(!v(ref_nested())) return false;
14746 { type = 1; return true;}
14750 template<typename V> bool encode(V& v) const
14752 return v(ref_nested());
14756 template<typename V> bool decode(size_t index, V& v)
14761 case 1: type = 1; return v(ref_nested());
14762 ref_nested().clear();
14767 template<typename V> bool encode(size_t index, V& v) const
14769 if(index != type) {return false;} return v(ref_nested());
14776 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
14778 size_t get_index() const {return type;}
14779 bool is_unknown() const { return type == 1; }
14780 void clear() {type = 0;}
14781 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
14782 template<typename V> bool decode(V& v)
14785 if(!v(ref_nested())) return false;
14786 { type = 1; return true;}
14790 template<typename V> bool encode(V& v) const
14792 return v(ref_nested());
14796 template<typename V> bool decode(size_t index, V& v)
14801 case 1: type = 1; return v(ref_nested());
14802 ref_nested().clear();
14807 template<typename V> bool encode(size_t index, V& v) const
14809 if(index != type) {return false;} return v(ref_nested());
14816 struct Extension_t : asn::typefield<true>
14818 ~Extension_t() {clear();}
14819 size_t get_index() const {return type;}
14820 bool is_unknown() const { return type == 1; }
14823 type = 0; ref_nested().clear();
14825 template<typename V> static inline void enumerate(V& v)
14830 template<typename V> bool decode(size_t index, V& v)
14835 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
14840 template<typename V> bool encode(size_t index, V& v) const
14842 if(index != type) return false;
14850 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
14852 size_t get_index() const {return type;}
14853 bool is_unknown() const { return type == 1; }
14854 void clear() {type = 0;}
14855 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
14856 template<typename V> bool decode(V& v)
14859 if(!v(ref_nested())) return false;
14860 { type = 1; return true;}
14864 template<typename V> bool encode(V& v) const
14866 return v(ref_nested());
14870 template<typename V> bool decode(size_t index, V& v)
14875 case 1: type = 1; return v(ref_nested());
14876 ref_nested().clear();
14881 template<typename V> bool encode(size_t index, V& v) const
14883 if(index != type) {return false;} return v(ref_nested());
14893 EN-DC-ResourceConfiguration ::= SEQUENCE {
14894 pDCPatSgNB ENUMERATED {present, not-present, ...},
14895 mCGresources ENUMERATED {present, not-present, ...},
14896 sCGresources ENUMERATED {present, not-present, ...},
14897 iE-Extensions ProtocolExtensionContainer { {EN-DC-ResourceConfigurationExtIEs} } OPTIONAL,
14902 struct EN_DC_ResourceConfiguration : asn::sequence<4, 0, true, 1>
14904 static constexpr const char* name() {return "EN-DC-ResourceConfiguration";}
14905 using parent_t = asn::sequence<4, 0, true, 1>;
14906 struct pDCPatSgNB_t : asn::enumerated<2, 0, true>
14908 static constexpr const char* name() {return "pDCPatSgNB_t";}
14909 using parent_t = asn::enumerated<2, 0, true>;
14917 pDCPatSgNB_t& ref_pDCPatSgNB() {return pDCPatSgNB;}
14918 pDCPatSgNB_t const& ref_pDCPatSgNB() const {return pDCPatSgNB;}
14919 struct mCGresources_t : asn::enumerated<2, 0, true>
14921 static constexpr const char* name() {return "mCGresources_t";}
14922 using parent_t = asn::enumerated<2, 0, true>;
14930 mCGresources_t& ref_mCGresources() {return mCGresources;}
14931 mCGresources_t const& ref_mCGresources() const {return mCGresources;}
14932 struct sCGresources_t : asn::enumerated<2, 0, true>
14934 static constexpr const char* name() {return "sCGresources_t";}
14935 using parent_t = asn::enumerated<2, 0, true>;
14943 sCGresources_t& ref_sCGresources() {return sCGresources;}
14944 sCGresources_t const& ref_sCGresources() const {return sCGresources;}
14945 struct iE_Extensions_t : ProtocolExtensionContainer<EN_DC_ResourceConfigurationExtIEs>
14947 static constexpr const char* name() {return "iE_Extensions_t";}
14948 using parent_t = ProtocolExtensionContainer<EN_DC_ResourceConfigurationExtIEs>;
14949 static constexpr bool optional = true;
14952 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
14953 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
14954 template<typename V> void decode(V& v)
14962 template<typename V> void encode(V& v) const
14972 pDCPatSgNB.clear();
14973 mCGresources.clear();
14974 sCGresources.clear();
14975 iE_Extensions.clear();
14979 pDCPatSgNB_t pDCPatSgNB;
14980 mCGresources_t mCGresources;
14981 sCGresources_t sCGresources;
14982 iE_Extensions_t iE_Extensions;
14986 ENB-ID ::= CHOICE {
14987 macro-eNB-ID BIT STRING (SIZE (20)),
14988 home-eNB-ID BIT STRING (SIZE (28)),
14990 short-Macro-eNB-ID BIT STRING (SIZE(18)),
14991 long-Macro-eNB-ID BIT STRING (SIZE(21))
14995 struct ENB_ID : asn::choice<4, 2, true>
14997 static constexpr const char* name() {return "ENB-ID";}
14998 using parent_t = asn::choice<4, 2, true>;
14999 index_type get_index() const {return index;}
15000 bool is_unknown() const {return index == 5;}
15001 void set_unknown() { set_index(5); }
15002 ~ENB_ID() {clear();}
15003 struct macro_eNB_ID_t : asn::bstring<>
15005 using constraint_t = asn::constraints<false,asn::one<20>>;
15006 static constexpr const char* name() {return "macro_eNB_ID_t";}
15007 using parent_t = asn::bstring<>;
15011 struct home_eNB_ID_t : asn::bstring<>
15013 using constraint_t = asn::constraints<false,asn::one<28>>;
15014 static constexpr const char* name() {return "home_eNB_ID_t";}
15015 using parent_t = asn::bstring<>;
15019 struct short_Macro_eNB_ID_t : asn::bstring<>
15021 using constraint_t = asn::constraints<false,asn::one<18>>;
15022 static constexpr const char* name() {return "short_Macro_eNB_ID_t";}
15023 using parent_t = asn::bstring<>;
15027 struct long_Macro_eNB_ID_t : asn::bstring<>
15029 using constraint_t = asn::constraints<false,asn::one<21>>;
15030 static constexpr const char* name() {return "long_Macro_eNB_ID_t";}
15031 using parent_t = asn::bstring<>;
15037 switch(get_index())
15039 case 1: var.destroy<macro_eNB_ID_t>(); break;
15040 case 2: var.destroy<home_eNB_ID_t>(); break;
15041 case 3: var.destroy<short_Macro_eNB_ID_t>(); break;
15042 case 4: var.destroy<long_Macro_eNB_ID_t>(); break;
15047 template<typename V> bool decode(size_t idx, V& v)
15052 case 1: set_index(1); return v(var.build<macro_eNB_ID_t>());
15053 case 2: set_index(2); return v(var.build<home_eNB_ID_t>());
15054 case 3: set_index(3); return v(var.build<short_Macro_eNB_ID_t>());
15055 case 4: set_index(4); return v(var.build<long_Macro_eNB_ID_t>());
15060 template<typename V> bool encode(V& v) const
15062 switch(get_index())
15064 case 1: return v(var.as<macro_eNB_ID_t>());
15065 case 2: return v(var.as<home_eNB_ID_t>());
15066 case 3: return v(var.as<short_Macro_eNB_ID_t>());
15067 case 4: return v(var.as<long_Macro_eNB_ID_t>());
15071 template<typename V> static inline void enumerate(V& v)
15073 v.template operator()<macro_eNB_ID_t>(1);
15074 v.template operator()<home_eNB_ID_t>(2);
15075 v.template operator()<short_Macro_eNB_ID_t>(3);
15076 v.template operator()<long_Macro_eNB_ID_t>(4);
15079 macro_eNB_ID_t& select_macro_eNB_ID() { if(get_index() != 1) { clear(); set_index(1); return var.build<macro_eNB_ID_t>();} return var.as<macro_eNB_ID_t>();}
15080 macro_eNB_ID_t const* get_macro_eNB_ID() const { if(get_index() == 1) { return &var.as<macro_eNB_ID_t>();} return nullptr; }
15081 home_eNB_ID_t& select_home_eNB_ID() { if(get_index() != 2) { clear(); set_index(2); return var.build<home_eNB_ID_t>();} return var.as<home_eNB_ID_t>();}
15082 home_eNB_ID_t const* get_home_eNB_ID() const { if(get_index() == 2) { return &var.as<home_eNB_ID_t>();} return nullptr; }
15083 short_Macro_eNB_ID_t& select_short_Macro_eNB_ID() { if(get_index() != 3) { clear(); set_index(3); return var.build<short_Macro_eNB_ID_t>();} return var.as<short_Macro_eNB_ID_t>();}
15084 short_Macro_eNB_ID_t const* get_short_Macro_eNB_ID() const { if(get_index() == 3) { return &var.as<short_Macro_eNB_ID_t>();} return nullptr; }
15085 long_Macro_eNB_ID_t& select_long_Macro_eNB_ID() { if(get_index() != 4) { clear(); set_index(4); return var.build<long_Macro_eNB_ID_t>();} return var.as<long_Macro_eNB_ID_t>();}
15086 long_Macro_eNB_ID_t const* get_long_Macro_eNB_ID() const { if(get_index() == 4) { return &var.as<long_Macro_eNB_ID_t>();} return nullptr; }
15088 void set_index(index_type i) {index = i; base::set();}
15091 char dummy1[sizeof(macro_eNB_ID_t)];
15092 char dummy2[sizeof(home_eNB_ID_t)];
15093 char dummy3[sizeof(short_Macro_eNB_ID_t)];
15094 char dummy4[sizeof(long_Macro_eNB_ID_t)];
15097 asn::variant<sizeof(union_type)> var;
15098 index_type index {0};
15101 EPLMNs ::= SEQUENCE (SIZE(1..maxnoofEPLMNs)) OF PLMN-Identity
15104 struct EPLMNs_elm : PLMN_Identity
15106 static constexpr const char* name() {return "EPLMNs_elm";}
15107 using parent_t = PLMN_Identity;
15110 struct EPLMNs : asn::sequenceof<EPLMNs_elm>
15112 static constexpr const char* name() {return "EPLMNs";}
15113 using parent_t = asn::sequenceof<EPLMNs_elm>;
15114 using constraint_t = asn::constraints<false,asn::span<1, maxnoofEPLMNs >>;
15118 UserPlaneTrafficActivityReport ::= ENUMERATED {inactive, re-activated, ...}
15121 struct UserPlaneTrafficActivityReport : asn::enumerated<2, 0, true>
15123 static constexpr const char* name() {return "UserPlaneTrafficActivityReport";}
15124 using parent_t = asn::enumerated<2, 0, true>;
15133 ERABActivityNotifyItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
15138 struct ERABActivityNotifyItem_ExtIEs
15140 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
15142 size_t get_index() const {return type;}
15143 bool is_unknown() const { return type == 1; }
15144 void clear() {type = 0;}
15145 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
15146 template<typename V> bool decode(V& v)
15149 if(!v(ref_nested())) return false;
15150 { type = 1; return true;}
15154 template<typename V> bool encode(V& v) const
15156 return v(ref_nested());
15160 template<typename V> bool decode(size_t index, V& v)
15165 case 1: type = 1; return v(ref_nested());
15166 ref_nested().clear();
15171 template<typename V> bool encode(size_t index, V& v) const
15173 if(index != type) {return false;} return v(ref_nested());
15180 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
15182 size_t get_index() const {return type;}
15183 bool is_unknown() const { return type == 1; }
15184 void clear() {type = 0;}
15185 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
15186 template<typename V> bool decode(V& v)
15189 if(!v(ref_nested())) return false;
15190 { type = 1; return true;}
15194 template<typename V> bool encode(V& v) const
15196 return v(ref_nested());
15200 template<typename V> bool decode(size_t index, V& v)
15205 case 1: type = 1; return v(ref_nested());
15206 ref_nested().clear();
15211 template<typename V> bool encode(size_t index, V& v) const
15213 if(index != type) {return false;} return v(ref_nested());
15220 struct Extension_t : asn::typefield<true>
15222 ~Extension_t() {clear();}
15223 size_t get_index() const {return type;}
15224 bool is_unknown() const { return type == 1; }
15227 type = 0; ref_nested().clear();
15229 template<typename V> static inline void enumerate(V& v)
15234 template<typename V> bool decode(size_t index, V& v)
15239 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
15244 template<typename V> bool encode(size_t index, V& v) const
15246 if(index != type) return false;
15254 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
15256 size_t get_index() const {return type;}
15257 bool is_unknown() const { return type == 1; }
15258 void clear() {type = 0;}
15259 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
15260 template<typename V> bool decode(V& v)
15263 if(!v(ref_nested())) return false;
15264 { type = 1; return true;}
15268 template<typename V> bool encode(V& v) const
15270 return v(ref_nested());
15274 template<typename V> bool decode(size_t index, V& v)
15279 case 1: type = 1; return v(ref_nested());
15280 ref_nested().clear();
15285 template<typename V> bool encode(size_t index, V& v) const
15287 if(index != type) {return false;} return v(ref_nested());
15297 ERABActivityNotifyItem ::= SEQUENCE {
15299 activityReport UserPlaneTrafficActivityReport,
15300 iE-Extensions ProtocolExtensionContainer { {ERABActivityNotifyItem-ExtIEs} } OPTIONAL,
15305 struct ERABActivityNotifyItem : asn::sequence<3, 0, true, 1>
15307 static constexpr const char* name() {return "ERABActivityNotifyItem";}
15308 using parent_t = asn::sequence<3, 0, true, 1>;
15309 struct e_RAB_ID_t : E_RAB_ID
15311 static constexpr const char* name() {return "e_RAB_ID_t";}
15312 using parent_t = E_RAB_ID;
15315 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
15316 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
15317 struct activityReport_t : UserPlaneTrafficActivityReport
15319 static constexpr const char* name() {return "activityReport_t";}
15320 using parent_t = UserPlaneTrafficActivityReport;
15323 activityReport_t& ref_activityReport() {return activityReport;}
15324 activityReport_t const& ref_activityReport() const {return activityReport;}
15325 struct iE_Extensions_t : ProtocolExtensionContainer<ERABActivityNotifyItem_ExtIEs>
15327 static constexpr const char* name() {return "iE_Extensions_t";}
15328 using parent_t = ProtocolExtensionContainer<ERABActivityNotifyItem_ExtIEs>;
15329 static constexpr bool optional = true;
15332 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
15333 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
15334 template<typename V> void decode(V& v)
15341 template<typename V> void encode(V& v) const
15351 activityReport.clear();
15352 iE_Extensions.clear();
15356 e_RAB_ID_t e_RAB_ID;
15357 activityReport_t activityReport;
15358 iE_Extensions_t iE_Extensions;
15362 ERABActivityNotifyItemList ::= SEQUENCE (SIZE (0..maxnoofBearers)) OF ERABActivityNotifyItem
15365 struct ERABActivityNotifyItemList_elm : ERABActivityNotifyItem
15367 static constexpr const char* name() {return "ERABActivityNotifyItemList_elm";}
15368 using parent_t = ERABActivityNotifyItem;
15371 struct ERABActivityNotifyItemList : asn::sequenceof<ERABActivityNotifyItemList_elm>
15373 static constexpr const char* name() {return "ERABActivityNotifyItemList";}
15374 using parent_t = asn::sequenceof<ERABActivityNotifyItemList_elm>;
15375 using constraint_t = asn::constraints<false,asn::span<0, maxnoofBearers >>;
15379 Transmission-Bandwidth ::= ENUMERATED {
15391 struct Transmission_Bandwidth : asn::enumerated<7, 1, true>
15393 static constexpr const char* name() {return "Transmission-Bandwidth";}
15394 using parent_t = asn::enumerated<7, 1, true>;
15408 OffsetOfNbiotChannelNumberToEARFCN ::= ENUMERATED {
15434 struct OffsetOfNbiotChannelNumberToEARFCN : asn::enumerated<21, 0, true>
15436 static constexpr const char* name() {return "OffsetOfNbiotChannelNumberToEARFCN";}
15437 using parent_t = asn::enumerated<21, 0, true>;
15465 NRS-NSSS-PowerOffset ::= ENUMERATED { minusThree, zero, three, ...}
15468 struct NRS_NSSS_PowerOffset : asn::enumerated<3, 0, true>
15470 static constexpr const char* name() {return "NRS-NSSS-PowerOffset";}
15471 using parent_t = asn::enumerated<3, 0, true>;
15481 NSSS-NumOccasionDifferentPrecoder ::= ENUMERATED { two, four, eight, ...}
15484 struct NSSS_NumOccasionDifferentPrecoder : asn::enumerated<3, 0, true>
15486 static constexpr const char* name() {return "NSSS-NumOccasionDifferentPrecoder";}
15487 using parent_t = asn::enumerated<3, 0, true>;
15497 FDD-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
15498 { ID id-UL-EARFCNExtension CRITICALITY reject EXTENSION EARFCNExtension PRESENCE optional}|
15499 { ID id-DL-EARFCNExtension CRITICALITY reject EXTENSION EARFCNExtension PRESENCE optional}|
15500 { ID id-OffsetOfNbiotChannelNumberToDL-EARFCN CRITICALITY reject EXTENSION OffsetOfNbiotChannelNumberToEARFCN PRESENCE optional}|
15501 { ID id-OffsetOfNbiotChannelNumberToUL-EARFCN CRITICALITY reject EXTENSION OffsetOfNbiotChannelNumberToEARFCN PRESENCE optional}|
15502 { ID id-NRS-NSSS-PowerOffset CRITICALITY ignore EXTENSION NRS-NSSS-PowerOffset PRESENCE optional}|
15503 { ID id-NSSS-NumOccasionDifferentPrecoder CRITICALITY ignore EXTENSION NSSS-NumOccasionDifferentPrecoder PRESENCE optional},
15508 struct FDD_Info_ExtIEs
15510 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
15512 size_t get_index() const {return type;}
15513 bool is_unknown() const { return type == 7; }
15514 void clear() {type = 0;}
15515 void select_id_UL_EARFCNExtension() { set(id_UL_EARFCNExtension); type=1;}
15516 void select_id_DL_EARFCNExtension() { set(id_DL_EARFCNExtension); type=2;}
15517 void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(id_OffsetOfNbiotChannelNumberToDL_EARFCN); type=3;}
15518 void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(id_OffsetOfNbiotChannelNumberToUL_EARFCN); type=4;}
15519 void select_id_NRS_NSSS_PowerOffset() { set(id_NRS_NSSS_PowerOffset); type=5;}
15520 void select_id_NSSS_NumOccasionDifferentPrecoder() { set(id_NSSS_NumOccasionDifferentPrecoder); type=6;}
15521 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
15522 template<typename V> bool decode(V& v)
15525 if(!v(ref_nested())) return false;
15526 if(equal(id_UL_EARFCNExtension)) { type = 1; return true; }
15527 else if(equal(id_DL_EARFCNExtension)) { type = 2; return true; }
15528 else if(equal(id_OffsetOfNbiotChannelNumberToDL_EARFCN)) { type = 3; return true; }
15529 else if(equal(id_OffsetOfNbiotChannelNumberToUL_EARFCN)) { type = 4; return true; }
15530 else if(equal(id_NRS_NSSS_PowerOffset)) { type = 5; return true; }
15531 else if(equal(id_NSSS_NumOccasionDifferentPrecoder)) { type = 6; return true; }
15532 else { type = 7; return true;}
15536 template<typename V> bool encode(V& v) const
15538 return v(ref_nested());
15542 template<typename V> bool decode(size_t index, V& v)
15547 case 1: type = 1; if(v(ref_nested())) { return equal(id_UL_EARFCNExtension);} return false;
15548 case 2: type = 2; if(v(ref_nested())) { return equal(id_DL_EARFCNExtension);} return false;
15549 case 3: type = 3; if(v(ref_nested())) { return equal(id_OffsetOfNbiotChannelNumberToDL_EARFCN);} return false;
15550 case 4: type = 4; if(v(ref_nested())) { return equal(id_OffsetOfNbiotChannelNumberToUL_EARFCN);} return false;
15551 case 5: type = 5; if(v(ref_nested())) { return equal(id_NRS_NSSS_PowerOffset);} return false;
15552 case 6: type = 6; if(v(ref_nested())) { return equal(id_NSSS_NumOccasionDifferentPrecoder);} return false;
15553 case 7: type = 7; return v(ref_nested());
15554 ref_nested().clear();
15559 template<typename V> bool encode(size_t index, V& v) const
15561 if(index != type) {return false;} return v(ref_nested());
15568 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
15570 size_t get_index() const {return type;}
15571 bool is_unknown() const { return type == 7; }
15572 void clear() {type = 0;}
15573 void select_id_UL_EARFCNExtension() { set(reject); type=1;}
15574 void select_id_DL_EARFCNExtension() { set(reject); type=2;}
15575 void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(reject); type=3;}
15576 void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(reject); type=4;}
15577 void select_id_NRS_NSSS_PowerOffset() { set(ignore); type=5;}
15578 void select_id_NSSS_NumOccasionDifferentPrecoder() { set(ignore); type=6;}
15579 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
15580 template<typename V> bool decode(V& v)
15583 if(!v(ref_nested())) return false;
15584 if(equal(reject)) { type = 1; return true; }
15585 else if(equal(reject)) { type = 2; return true; }
15586 else if(equal(reject)) { type = 3; return true; }
15587 else if(equal(reject)) { type = 4; return true; }
15588 else if(equal(ignore)) { type = 5; return true; }
15589 else if(equal(ignore)) { type = 6; return true; }
15590 else { type = 7; return true;}
15594 template<typename V> bool encode(V& v) const
15596 return v(ref_nested());
15600 template<typename V> bool decode(size_t index, V& v)
15605 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
15606 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
15607 case 3: type = 3; if(v(ref_nested())) { return equal(reject);} return false;
15608 case 4: type = 4; if(v(ref_nested())) { return equal(reject);} return false;
15609 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
15610 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
15611 case 7: type = 7; return v(ref_nested());
15612 ref_nested().clear();
15617 template<typename V> bool encode(size_t index, V& v) const
15619 if(index != type) {return false;} return v(ref_nested());
15626 struct Extension_t : asn::typefield<true>
15628 ~Extension_t() {clear();}
15629 size_t get_index() const {return type;}
15630 EARFCNExtension& select_id_UL_EARFCNExtension() { return set<EARFCNExtension>(1); }
15631 EARFCNExtension const* get_id_UL_EARFCNExtension() const { return get<EARFCNExtension>(1); }
15632 EARFCNExtension& select_id_DL_EARFCNExtension() { return set<EARFCNExtension>(2); }
15633 EARFCNExtension const* get_id_DL_EARFCNExtension() const { return get<EARFCNExtension>(2); }
15634 OffsetOfNbiotChannelNumberToEARFCN& select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { return set<OffsetOfNbiotChannelNumberToEARFCN>(3); }
15635 OffsetOfNbiotChannelNumberToEARFCN const* get_id_OffsetOfNbiotChannelNumberToDL_EARFCN() const { return get<OffsetOfNbiotChannelNumberToEARFCN>(3); }
15636 OffsetOfNbiotChannelNumberToEARFCN& select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { return set<OffsetOfNbiotChannelNumberToEARFCN>(4); }
15637 OffsetOfNbiotChannelNumberToEARFCN const* get_id_OffsetOfNbiotChannelNumberToUL_EARFCN() const { return get<OffsetOfNbiotChannelNumberToEARFCN>(4); }
15638 NRS_NSSS_PowerOffset& select_id_NRS_NSSS_PowerOffset() { return set<NRS_NSSS_PowerOffset>(5); }
15639 NRS_NSSS_PowerOffset const* get_id_NRS_NSSS_PowerOffset() const { return get<NRS_NSSS_PowerOffset>(5); }
15640 NSSS_NumOccasionDifferentPrecoder& select_id_NSSS_NumOccasionDifferentPrecoder() { return set<NSSS_NumOccasionDifferentPrecoder>(6); }
15641 NSSS_NumOccasionDifferentPrecoder const* get_id_NSSS_NumOccasionDifferentPrecoder() const { return get<NSSS_NumOccasionDifferentPrecoder>(6); }
15642 bool is_unknown() const { return type == 7; }
15647 case 1: var.destroy<EARFCNExtension>(); break;
15648 case 2: var.destroy<EARFCNExtension>(); break;
15649 case 3: var.destroy<OffsetOfNbiotChannelNumberToEARFCN>(); break;
15650 case 4: var.destroy<OffsetOfNbiotChannelNumberToEARFCN>(); break;
15651 case 5: var.destroy<NRS_NSSS_PowerOffset>(); break;
15652 case 6: var.destroy<NSSS_NumOccasionDifferentPrecoder>(); break;
15654 type = 0; ref_nested().clear();
15656 template<typename V> static inline void enumerate(V& v)
15658 v.template operator()<EARFCNExtension>(1);
15659 v.template operator()<EARFCNExtension>(2);
15660 v.template operator()<OffsetOfNbiotChannelNumberToEARFCN>(3);
15661 v.template operator()<OffsetOfNbiotChannelNumberToEARFCN>(4);
15662 v.template operator()<NRS_NSSS_PowerOffset>(5);
15663 v.template operator()<NSSS_NumOccasionDifferentPrecoder>(6);
15667 template<typename V> bool decode(size_t index, V& v)
15672 case 1: v(select_id_UL_EARFCNExtension()); return true;
15673 case 2: v(select_id_DL_EARFCNExtension()); return true;
15674 case 3: v(select_id_OffsetOfNbiotChannelNumberToDL_EARFCN()); return true;
15675 case 4: v(select_id_OffsetOfNbiotChannelNumberToUL_EARFCN()); return true;
15676 case 5: v(select_id_NRS_NSSS_PowerOffset()); return true;
15677 case 6: v(select_id_NSSS_NumOccasionDifferentPrecoder()); return true;
15678 case 7: if(type != 7) {clear(); asn::base::set();} type = 7; return true;
15683 template<typename V> bool encode(size_t index, V& v) const
15685 if(index != type) return false;
15688 case 1: v(var.as<EARFCNExtension>()); return true;
15689 case 2: v(var.as<EARFCNExtension>()); return true;
15690 case 3: v(var.as<OffsetOfNbiotChannelNumberToEARFCN>()); return true;
15691 case 4: v(var.as<OffsetOfNbiotChannelNumberToEARFCN>()); return true;
15692 case 5: v(var.as<NRS_NSSS_PowerOffset>()); return true;
15693 case 6: v(var.as<NSSS_NumOccasionDifferentPrecoder>()); return true;
15699 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
15700 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
15703 char dummy1[sizeof(EARFCNExtension)];
15704 char dummy2[sizeof(NRS_NSSS_PowerOffset)];
15705 char dummy3[sizeof(NSSS_NumOccasionDifferentPrecoder)];
15706 char dummy4[sizeof(OffsetOfNbiotChannelNumberToEARFCN)];
15709 asn::variant<sizeof(union_type)> var;
15713 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
15715 size_t get_index() const {return type;}
15716 bool is_unknown() const { return type == 7; }
15717 void clear() {type = 0;}
15718 void select_id_UL_EARFCNExtension() { set(optional); type=1;}
15719 void select_id_DL_EARFCNExtension() { set(optional); type=2;}
15720 void select_id_OffsetOfNbiotChannelNumberToDL_EARFCN() { set(optional); type=3;}
15721 void select_id_OffsetOfNbiotChannelNumberToUL_EARFCN() { set(optional); type=4;}
15722 void select_id_NRS_NSSS_PowerOffset() { set(optional); type=5;}
15723 void select_id_NSSS_NumOccasionDifferentPrecoder() { set(optional); type=6;}
15724 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
15725 template<typename V> bool decode(V& v)
15728 if(!v(ref_nested())) return false;
15729 if(equal(optional)) { type = 1; return true; }
15730 else if(equal(optional)) { type = 2; return true; }
15731 else if(equal(optional)) { type = 3; return true; }
15732 else if(equal(optional)) { type = 4; return true; }
15733 else if(equal(optional)) { type = 5; return true; }
15734 else if(equal(optional)) { type = 6; return true; }
15735 else { type = 7; return true;}
15739 template<typename V> bool encode(V& v) const
15741 return v(ref_nested());
15745 template<typename V> bool decode(size_t index, V& v)
15750 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
15751 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
15752 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
15753 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
15754 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
15755 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
15756 case 7: type = 7; return v(ref_nested());
15757 ref_nested().clear();
15762 template<typename V> bool encode(size_t index, V& v) const
15764 if(index != type) {return false;} return v(ref_nested());
15774 FDD-Info ::= SEQUENCE {
15777 uL-Transmission-Bandwidth Transmission-Bandwidth,
15778 dL-Transmission-Bandwidth Transmission-Bandwidth,
15779 iE-Extensions ProtocolExtensionContainer { {FDD-Info-ExtIEs} } OPTIONAL,
15784 struct FDD_Info : asn::sequence<5, 0, true, 1>
15786 static constexpr const char* name() {return "FDD-Info";}
15787 using parent_t = asn::sequence<5, 0, true, 1>;
15788 struct uL_EARFCN_t : EARFCN
15790 static constexpr const char* name() {return "uL_EARFCN_t";}
15791 using parent_t = EARFCN;
15794 uL_EARFCN_t& ref_uL_EARFCN() {return uL_EARFCN;}
15795 uL_EARFCN_t const& ref_uL_EARFCN() const {return uL_EARFCN;}
15796 struct dL_EARFCN_t : EARFCN
15798 static constexpr const char* name() {return "dL_EARFCN_t";}
15799 using parent_t = EARFCN;
15802 dL_EARFCN_t& ref_dL_EARFCN() {return dL_EARFCN;}
15803 dL_EARFCN_t const& ref_dL_EARFCN() const {return dL_EARFCN;}
15804 struct uL_Transmission_Bandwidth_t : Transmission_Bandwidth
15806 static constexpr const char* name() {return "uL_Transmission_Bandwidth_t";}
15807 using parent_t = Transmission_Bandwidth;
15810 uL_Transmission_Bandwidth_t& ref_uL_Transmission_Bandwidth() {return uL_Transmission_Bandwidth;}
15811 uL_Transmission_Bandwidth_t const& ref_uL_Transmission_Bandwidth() const {return uL_Transmission_Bandwidth;}
15812 struct dL_Transmission_Bandwidth_t : Transmission_Bandwidth
15814 static constexpr const char* name() {return "dL_Transmission_Bandwidth_t";}
15815 using parent_t = Transmission_Bandwidth;
15818 dL_Transmission_Bandwidth_t& ref_dL_Transmission_Bandwidth() {return dL_Transmission_Bandwidth;}
15819 dL_Transmission_Bandwidth_t const& ref_dL_Transmission_Bandwidth() const {return dL_Transmission_Bandwidth;}
15820 struct iE_Extensions_t : ProtocolExtensionContainer<FDD_Info_ExtIEs>
15822 static constexpr const char* name() {return "iE_Extensions_t";}
15823 using parent_t = ProtocolExtensionContainer<FDD_Info_ExtIEs>;
15824 static constexpr bool optional = true;
15827 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
15828 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
15829 template<typename V> void decode(V& v)
15833 v(uL_Transmission_Bandwidth);
15834 v(dL_Transmission_Bandwidth);
15838 template<typename V> void encode(V& v) const
15842 v(uL_Transmission_Bandwidth);
15843 v(dL_Transmission_Bandwidth);
15851 uL_Transmission_Bandwidth.clear();
15852 dL_Transmission_Bandwidth.clear();
15853 iE_Extensions.clear();
15857 uL_EARFCN_t uL_EARFCN;
15858 dL_EARFCN_t dL_EARFCN;
15859 uL_Transmission_Bandwidth_t uL_Transmission_Bandwidth;
15860 dL_Transmission_Bandwidth_t dL_Transmission_Bandwidth;
15861 iE_Extensions_t iE_Extensions;
15865 SubframeAssignment ::= ENUMERATED {
15877 struct SubframeAssignment : asn::enumerated<7, 0, true>
15879 static constexpr const char* name() {return "SubframeAssignment";}
15880 using parent_t = asn::enumerated<7, 0, true>;
15894 SpecialSubframePatterns ::= ENUMERATED {
15908 struct SpecialSubframePatterns : asn::enumerated<9, 0, true>
15910 static constexpr const char* name() {return "SpecialSubframePatterns";}
15911 using parent_t = asn::enumerated<9, 0, true>;
15927 SpecialSubframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
15932 struct SpecialSubframe_Info_ExtIEs
15934 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
15936 size_t get_index() const {return type;}
15937 bool is_unknown() const { return type == 1; }
15938 void clear() {type = 0;}
15939 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
15940 template<typename V> bool decode(V& v)
15943 if(!v(ref_nested())) return false;
15944 { type = 1; return true;}
15948 template<typename V> bool encode(V& v) const
15950 return v(ref_nested());
15954 template<typename V> bool decode(size_t index, V& v)
15959 case 1: type = 1; return v(ref_nested());
15960 ref_nested().clear();
15965 template<typename V> bool encode(size_t index, V& v) const
15967 if(index != type) {return false;} return v(ref_nested());
15974 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
15976 size_t get_index() const {return type;}
15977 bool is_unknown() const { return type == 1; }
15978 void clear() {type = 0;}
15979 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
15980 template<typename V> bool decode(V& v)
15983 if(!v(ref_nested())) return false;
15984 { type = 1; return true;}
15988 template<typename V> bool encode(V& v) const
15990 return v(ref_nested());
15994 template<typename V> bool decode(size_t index, V& v)
15999 case 1: type = 1; return v(ref_nested());
16000 ref_nested().clear();
16005 template<typename V> bool encode(size_t index, V& v) const
16007 if(index != type) {return false;} return v(ref_nested());
16014 struct Extension_t : asn::typefield<true>
16016 ~Extension_t() {clear();}
16017 size_t get_index() const {return type;}
16018 bool is_unknown() const { return type == 1; }
16021 type = 0; ref_nested().clear();
16023 template<typename V> static inline void enumerate(V& v)
16028 template<typename V> bool decode(size_t index, V& v)
16033 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
16038 template<typename V> bool encode(size_t index, V& v) const
16040 if(index != type) return false;
16048 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16050 size_t get_index() const {return type;}
16051 bool is_unknown() const { return type == 1; }
16052 void clear() {type = 0;}
16053 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16054 template<typename V> bool decode(V& v)
16057 if(!v(ref_nested())) return false;
16058 { type = 1; return true;}
16062 template<typename V> bool encode(V& v) const
16064 return v(ref_nested());
16068 template<typename V> bool decode(size_t index, V& v)
16073 case 1: type = 1; return v(ref_nested());
16074 ref_nested().clear();
16079 template<typename V> bool encode(size_t index, V& v) const
16081 if(index != type) {return false;} return v(ref_nested());
16091 SpecialSubframe-Info ::= SEQUENCE {
16092 specialSubframePatterns SpecialSubframePatterns,
16093 cyclicPrefixDL CyclicPrefixDL,
16094 cyclicPrefixUL CyclicPrefixUL,
16095 iE-Extensions ProtocolExtensionContainer { {SpecialSubframe-Info-ExtIEs} } OPTIONAL,
16100 struct SpecialSubframe_Info : asn::sequence<4, 0, true, 1>
16102 static constexpr const char* name() {return "SpecialSubframe-Info";}
16103 using parent_t = asn::sequence<4, 0, true, 1>;
16104 struct specialSubframePatterns_t : SpecialSubframePatterns
16106 static constexpr const char* name() {return "specialSubframePatterns_t";}
16107 using parent_t = SpecialSubframePatterns;
16110 specialSubframePatterns_t& ref_specialSubframePatterns() {return specialSubframePatterns;}
16111 specialSubframePatterns_t const& ref_specialSubframePatterns() const {return specialSubframePatterns;}
16112 struct cyclicPrefixDL_t : CyclicPrefixDL
16114 static constexpr const char* name() {return "cyclicPrefixDL_t";}
16115 using parent_t = CyclicPrefixDL;
16118 cyclicPrefixDL_t& ref_cyclicPrefixDL() {return cyclicPrefixDL;}
16119 cyclicPrefixDL_t const& ref_cyclicPrefixDL() const {return cyclicPrefixDL;}
16120 struct cyclicPrefixUL_t : CyclicPrefixUL
16122 static constexpr const char* name() {return "cyclicPrefixUL_t";}
16123 using parent_t = CyclicPrefixUL;
16126 cyclicPrefixUL_t& ref_cyclicPrefixUL() {return cyclicPrefixUL;}
16127 cyclicPrefixUL_t const& ref_cyclicPrefixUL() const {return cyclicPrefixUL;}
16128 struct iE_Extensions_t : ProtocolExtensionContainer<SpecialSubframe_Info_ExtIEs>
16130 static constexpr const char* name() {return "iE_Extensions_t";}
16131 using parent_t = ProtocolExtensionContainer<SpecialSubframe_Info_ExtIEs>;
16132 static constexpr bool optional = true;
16135 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
16136 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
16137 template<typename V> void decode(V& v)
16139 v(specialSubframePatterns);
16145 template<typename V> void encode(V& v) const
16147 v(specialSubframePatterns);
16155 specialSubframePatterns.clear();
16156 cyclicPrefixDL.clear();
16157 cyclicPrefixUL.clear();
16158 iE_Extensions.clear();
16162 specialSubframePatterns_t specialSubframePatterns;
16163 cyclicPrefixDL_t cyclicPrefixDL;
16164 cyclicPrefixUL_t cyclicPrefixUL;
16165 iE_Extensions_t iE_Extensions;
16169 TDD-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
16170 { ID id-AdditionalSpecialSubframe-Info CRITICALITY ignore EXTENSION AdditionalSpecialSubframe-Info PRESENCE optional}|
16171 { ID id-eARFCNExtension CRITICALITY reject EXTENSION EARFCNExtension PRESENCE optional}|
16172 { ID id-AdditionalSpecialSubframeExtension-Info CRITICALITY ignore EXTENSION AdditionalSpecialSubframeExtension-Info PRESENCE optional},
16177 struct TDD_Info_ExtIEs
16179 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
16181 size_t get_index() const {return type;}
16182 bool is_unknown() const { return type == 4; }
16183 void clear() {type = 0;}
16184 void select_id_AdditionalSpecialSubframe_Info() { set(id_AdditionalSpecialSubframe_Info); type=1;}
16185 void select_id_eARFCNExtension() { set(id_eARFCNExtension); type=2;}
16186 void select_id_AdditionalSpecialSubframeExtension_Info() { set(id_AdditionalSpecialSubframeExtension_Info); type=3;}
16187 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
16188 template<typename V> bool decode(V& v)
16191 if(!v(ref_nested())) return false;
16192 if(equal(id_AdditionalSpecialSubframe_Info)) { type = 1; return true; }
16193 else if(equal(id_eARFCNExtension)) { type = 2; return true; }
16194 else if(equal(id_AdditionalSpecialSubframeExtension_Info)) { type = 3; return true; }
16195 else { type = 4; return true;}
16199 template<typename V> bool encode(V& v) const
16201 return v(ref_nested());
16205 template<typename V> bool decode(size_t index, V& v)
16210 case 1: type = 1; if(v(ref_nested())) { return equal(id_AdditionalSpecialSubframe_Info);} return false;
16211 case 2: type = 2; if(v(ref_nested())) { return equal(id_eARFCNExtension);} return false;
16212 case 3: type = 3; if(v(ref_nested())) { return equal(id_AdditionalSpecialSubframeExtension_Info);} return false;
16213 case 4: type = 4; return v(ref_nested());
16214 ref_nested().clear();
16219 template<typename V> bool encode(size_t index, V& v) const
16221 if(index != type) {return false;} return v(ref_nested());
16228 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
16230 size_t get_index() const {return type;}
16231 bool is_unknown() const { return type == 4; }
16232 void clear() {type = 0;}
16233 void select_id_AdditionalSpecialSubframe_Info() { set(ignore); type=1;}
16234 void select_id_eARFCNExtension() { set(reject); type=2;}
16235 void select_id_AdditionalSpecialSubframeExtension_Info() { set(ignore); type=3;}
16236 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
16237 template<typename V> bool decode(V& v)
16240 if(!v(ref_nested())) return false;
16241 if(equal(ignore)) { type = 1; return true; }
16242 else if(equal(reject)) { type = 2; return true; }
16243 else if(equal(ignore)) { type = 3; return true; }
16244 else { type = 4; return true;}
16248 template<typename V> bool encode(V& v) const
16250 return v(ref_nested());
16254 template<typename V> bool decode(size_t index, V& v)
16259 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
16260 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
16261 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
16262 case 4: type = 4; return v(ref_nested());
16263 ref_nested().clear();
16268 template<typename V> bool encode(size_t index, V& v) const
16270 if(index != type) {return false;} return v(ref_nested());
16277 struct Extension_t : asn::typefield<true>
16279 ~Extension_t() {clear();}
16280 size_t get_index() const {return type;}
16281 AdditionalSpecialSubframe_Info& select_id_AdditionalSpecialSubframe_Info() { return set<AdditionalSpecialSubframe_Info>(1); }
16282 AdditionalSpecialSubframe_Info const* get_id_AdditionalSpecialSubframe_Info() const { return get<AdditionalSpecialSubframe_Info>(1); }
16283 EARFCNExtension& select_id_eARFCNExtension() { return set<EARFCNExtension>(2); }
16284 EARFCNExtension const* get_id_eARFCNExtension() const { return get<EARFCNExtension>(2); }
16285 AdditionalSpecialSubframeExtension_Info& select_id_AdditionalSpecialSubframeExtension_Info() { return set<AdditionalSpecialSubframeExtension_Info>(3); }
16286 AdditionalSpecialSubframeExtension_Info const* get_id_AdditionalSpecialSubframeExtension_Info() const { return get<AdditionalSpecialSubframeExtension_Info>(3); }
16287 bool is_unknown() const { return type == 4; }
16292 case 1: var.destroy<AdditionalSpecialSubframe_Info>(); break;
16293 case 2: var.destroy<EARFCNExtension>(); break;
16294 case 3: var.destroy<AdditionalSpecialSubframeExtension_Info>(); break;
16296 type = 0; ref_nested().clear();
16298 template<typename V> static inline void enumerate(V& v)
16300 v.template operator()<AdditionalSpecialSubframe_Info>(1);
16301 v.template operator()<EARFCNExtension>(2);
16302 v.template operator()<AdditionalSpecialSubframeExtension_Info>(3);
16306 template<typename V> bool decode(size_t index, V& v)
16311 case 1: v(select_id_AdditionalSpecialSubframe_Info()); return true;
16312 case 2: v(select_id_eARFCNExtension()); return true;
16313 case 3: v(select_id_AdditionalSpecialSubframeExtension_Info()); return true;
16314 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
16319 template<typename V> bool encode(size_t index, V& v) const
16321 if(index != type) return false;
16324 case 1: v(var.as<AdditionalSpecialSubframe_Info>()); return true;
16325 case 2: v(var.as<EARFCNExtension>()); return true;
16326 case 3: v(var.as<AdditionalSpecialSubframeExtension_Info>()); return true;
16332 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
16333 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
16336 char dummy1[sizeof(AdditionalSpecialSubframeExtension_Info)];
16337 char dummy2[sizeof(AdditionalSpecialSubframe_Info)];
16338 char dummy3[sizeof(EARFCNExtension)];
16341 asn::variant<sizeof(union_type)> var;
16345 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16347 size_t get_index() const {return type;}
16348 bool is_unknown() const { return type == 4; }
16349 void clear() {type = 0;}
16350 void select_id_AdditionalSpecialSubframe_Info() { set(optional); type=1;}
16351 void select_id_eARFCNExtension() { set(optional); type=2;}
16352 void select_id_AdditionalSpecialSubframeExtension_Info() { set(optional); type=3;}
16353 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16354 template<typename V> bool decode(V& v)
16357 if(!v(ref_nested())) return false;
16358 if(equal(optional)) { type = 1; return true; }
16359 else if(equal(optional)) { type = 2; return true; }
16360 else if(equal(optional)) { type = 3; return true; }
16361 else { type = 4; return true;}
16365 template<typename V> bool encode(V& v) const
16367 return v(ref_nested());
16371 template<typename V> bool decode(size_t index, V& v)
16376 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
16377 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
16378 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
16379 case 4: type = 4; return v(ref_nested());
16380 ref_nested().clear();
16385 template<typename V> bool encode(size_t index, V& v) const
16387 if(index != type) {return false;} return v(ref_nested());
16397 TDD-Info ::= SEQUENCE {
16399 transmission-Bandwidth Transmission-Bandwidth,
16400 subframeAssignment SubframeAssignment,
16401 specialSubframe-Info SpecialSubframe-Info,
16402 iE-Extensions ProtocolExtensionContainer { {TDD-Info-ExtIEs} } OPTIONAL,
16407 struct TDD_Info : asn::sequence<5, 0, true, 1>
16409 static constexpr const char* name() {return "TDD-Info";}
16410 using parent_t = asn::sequence<5, 0, true, 1>;
16411 struct eARFCN_t : EARFCN
16413 static constexpr const char* name() {return "eARFCN_t";}
16414 using parent_t = EARFCN;
16417 eARFCN_t& ref_eARFCN() {return eARFCN;}
16418 eARFCN_t const& ref_eARFCN() const {return eARFCN;}
16419 struct transmission_Bandwidth_t : Transmission_Bandwidth
16421 static constexpr const char* name() {return "transmission_Bandwidth_t";}
16422 using parent_t = Transmission_Bandwidth;
16425 transmission_Bandwidth_t& ref_transmission_Bandwidth() {return transmission_Bandwidth;}
16426 transmission_Bandwidth_t const& ref_transmission_Bandwidth() const {return transmission_Bandwidth;}
16427 struct subframeAssignment_t : SubframeAssignment
16429 static constexpr const char* name() {return "subframeAssignment_t";}
16430 using parent_t = SubframeAssignment;
16433 subframeAssignment_t& ref_subframeAssignment() {return subframeAssignment;}
16434 subframeAssignment_t const& ref_subframeAssignment() const {return subframeAssignment;}
16435 struct specialSubframe_Info_t : SpecialSubframe_Info
16437 static constexpr const char* name() {return "specialSubframe_Info_t";}
16438 using parent_t = SpecialSubframe_Info;
16441 specialSubframe_Info_t& ref_specialSubframe_Info() {return specialSubframe_Info;}
16442 specialSubframe_Info_t const& ref_specialSubframe_Info() const {return specialSubframe_Info;}
16443 struct iE_Extensions_t : ProtocolExtensionContainer<TDD_Info_ExtIEs>
16445 static constexpr const char* name() {return "iE_Extensions_t";}
16446 using parent_t = ProtocolExtensionContainer<TDD_Info_ExtIEs>;
16447 static constexpr bool optional = true;
16450 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
16451 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
16452 template<typename V> void decode(V& v)
16455 v(transmission_Bandwidth);
16456 v(subframeAssignment);
16457 v(specialSubframe_Info);
16461 template<typename V> void encode(V& v) const
16464 v(transmission_Bandwidth);
16465 v(subframeAssignment);
16466 v(specialSubframe_Info);
16473 transmission_Bandwidth.clear();
16474 subframeAssignment.clear();
16475 specialSubframe_Info.clear();
16476 iE_Extensions.clear();
16481 transmission_Bandwidth_t transmission_Bandwidth;
16482 subframeAssignment_t subframeAssignment;
16483 specialSubframe_Info_t specialSubframe_Info;
16484 iE_Extensions_t iE_Extensions;
16488 EUTRA-Mode-Info ::= CHOICE {
16495 struct EUTRA_Mode_Info : asn::choice<2, 0, true>
16497 static constexpr const char* name() {return "EUTRA-Mode-Info";}
16498 using parent_t = asn::choice<2, 0, true>;
16499 index_type get_index() const {return index;}
16500 bool is_unknown() const {return index == 3;}
16501 void set_unknown() { set_index(3); }
16502 ~EUTRA_Mode_Info() {clear();}
16503 struct fDD_t : FDD_Info
16505 static constexpr const char* name() {return "fDD_t";}
16506 using parent_t = FDD_Info;
16509 struct tDD_t : TDD_Info
16511 static constexpr const char* name() {return "tDD_t";}
16512 using parent_t = TDD_Info;
16517 switch(get_index())
16519 case 1: var.destroy<fDD_t>(); break;
16520 case 2: var.destroy<tDD_t>(); break;
16525 template<typename V> bool decode(size_t idx, V& v)
16530 case 1: set_index(1); return v(var.build<fDD_t>());
16531 case 2: set_index(2); return v(var.build<tDD_t>());
16536 template<typename V> bool encode(V& v) const
16538 switch(get_index())
16540 case 1: return v(var.as<fDD_t>());
16541 case 2: return v(var.as<tDD_t>());
16545 template<typename V> static inline void enumerate(V& v)
16547 v.template operator()<fDD_t>(1);
16548 v.template operator()<tDD_t>(2);
16551 fDD_t& select_fDD() { if(get_index() != 1) { clear(); set_index(1); return var.build<fDD_t>();} return var.as<fDD_t>();}
16552 fDD_t const* get_fDD() const { if(get_index() == 1) { return &var.as<fDD_t>();} return nullptr; }
16553 tDD_t& select_tDD() { if(get_index() != 2) { clear(); set_index(2); return var.build<tDD_t>();} return var.as<tDD_t>();}
16554 tDD_t const* get_tDD() const { if(get_index() == 2) { return &var.as<tDD_t>();} return nullptr; }
16556 void set_index(index_type i) {index = i; base::set();}
16559 char dummy1[sizeof(fDD_t)];
16560 char dummy2[sizeof(tDD_t)];
16563 asn::variant<sizeof(union_type)> var;
16564 index_type index {0};
16567 EUTRANTraceID ::= OCTET STRING (SIZE (8))
16570 struct EUTRANTraceID : asn::ostring<>
16572 using constraint_t = asn::constraints<false,asn::one<8>>;
16573 static constexpr const char* name() {return "EUTRANTraceID";}
16574 using parent_t = asn::ostring<>;
16579 EncryptionAlgorithms ::= BIT STRING (SIZE (16, ...))
16582 struct EncryptionAlgorithms : asn::bstring<>
16584 using constraint_t = asn::constraints<true,asn::one<16>>;
16585 static constexpr const char* name() {return "EncryptionAlgorithms";}
16586 using parent_t = asn::bstring<>;
16591 RNTP-Threshold ::= ENUMERATED {
16612 struct RNTP_Threshold : asn::enumerated<16, 0, true>
16614 static constexpr const char* name() {return "RNTP-Threshold";}
16615 using parent_t = asn::enumerated<16, 0, true>;
16638 EnhancedRNTPStartTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
16643 struct EnhancedRNTPStartTime_ExtIEs
16645 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
16647 size_t get_index() const {return type;}
16648 bool is_unknown() const { return type == 1; }
16649 void clear() {type = 0;}
16650 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
16651 template<typename V> bool decode(V& v)
16654 if(!v(ref_nested())) return false;
16655 { type = 1; return true;}
16659 template<typename V> bool encode(V& v) const
16661 return v(ref_nested());
16665 template<typename V> bool decode(size_t index, V& v)
16670 case 1: type = 1; return v(ref_nested());
16671 ref_nested().clear();
16676 template<typename V> bool encode(size_t index, V& v) const
16678 if(index != type) {return false;} return v(ref_nested());
16685 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
16687 size_t get_index() const {return type;}
16688 bool is_unknown() const { return type == 1; }
16689 void clear() {type = 0;}
16690 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
16691 template<typename V> bool decode(V& v)
16694 if(!v(ref_nested())) return false;
16695 { type = 1; return true;}
16699 template<typename V> bool encode(V& v) const
16701 return v(ref_nested());
16705 template<typename V> bool decode(size_t index, V& v)
16710 case 1: type = 1; return v(ref_nested());
16711 ref_nested().clear();
16716 template<typename V> bool encode(size_t index, V& v) const
16718 if(index != type) {return false;} return v(ref_nested());
16725 struct Extension_t : asn::typefield<true>
16727 ~Extension_t() {clear();}
16728 size_t get_index() const {return type;}
16729 bool is_unknown() const { return type == 1; }
16732 type = 0; ref_nested().clear();
16734 template<typename V> static inline void enumerate(V& v)
16739 template<typename V> bool decode(size_t index, V& v)
16744 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
16749 template<typename V> bool encode(size_t index, V& v) const
16751 if(index != type) return false;
16759 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16761 size_t get_index() const {return type;}
16762 bool is_unknown() const { return type == 1; }
16763 void clear() {type = 0;}
16764 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16765 template<typename V> bool decode(V& v)
16768 if(!v(ref_nested())) return false;
16769 { type = 1; return true;}
16773 template<typename V> bool encode(V& v) const
16775 return v(ref_nested());
16779 template<typename V> bool decode(size_t index, V& v)
16784 case 1: type = 1; return v(ref_nested());
16785 ref_nested().clear();
16790 template<typename V> bool encode(size_t index, V& v) const
16792 if(index != type) {return false;} return v(ref_nested());
16802 EnhancedRNTPStartTime ::= SEQUENCE {
16803 startSFN INTEGER (0..1023, ...),
16804 startSubframeNumber INTEGER (0..9, ...),
16805 iE-Extensions ProtocolExtensionContainer { {EnhancedRNTPStartTime-ExtIEs} } OPTIONAL,
16810 struct EnhancedRNTPStartTime : asn::sequence<3, 0, true, 1>
16812 static constexpr const char* name() {return "EnhancedRNTPStartTime";}
16813 using parent_t = asn::sequence<3, 0, true, 1>;
16814 struct startSFN_t : asn::integer<>
16816 using constraint_t = asn::constraints<true,asn::span<0, 1023>>;
16817 static constexpr const char* name() {return "startSFN_t";}
16818 using parent_t = asn::integer<>;
16822 startSFN_t& ref_startSFN() {return startSFN;}
16823 startSFN_t const& ref_startSFN() const {return startSFN;}
16824 struct startSubframeNumber_t : asn::integer<>
16826 using constraint_t = asn::constraints<true,asn::span<0, 9>>;
16827 static constexpr const char* name() {return "startSubframeNumber_t";}
16828 using parent_t = asn::integer<>;
16832 startSubframeNumber_t& ref_startSubframeNumber() {return startSubframeNumber;}
16833 startSubframeNumber_t const& ref_startSubframeNumber() const {return startSubframeNumber;}
16834 struct iE_Extensions_t : ProtocolExtensionContainer<EnhancedRNTPStartTime_ExtIEs>
16836 static constexpr const char* name() {return "iE_Extensions_t";}
16837 using parent_t = ProtocolExtensionContainer<EnhancedRNTPStartTime_ExtIEs>;
16838 static constexpr bool optional = true;
16841 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
16842 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
16843 template<typename V> void decode(V& v)
16846 v(startSubframeNumber);
16850 template<typename V> void encode(V& v) const
16853 v(startSubframeNumber);
16860 startSubframeNumber.clear();
16861 iE_Extensions.clear();
16865 startSFN_t startSFN;
16866 startSubframeNumber_t startSubframeNumber;
16867 iE_Extensions_t iE_Extensions;
16871 EnhancedRNTP-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
16876 struct EnhancedRNTP_ExtIEs
16878 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
16880 size_t get_index() const {return type;}
16881 bool is_unknown() const { return type == 1; }
16882 void clear() {type = 0;}
16883 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
16884 template<typename V> bool decode(V& v)
16887 if(!v(ref_nested())) return false;
16888 { type = 1; return true;}
16892 template<typename V> bool encode(V& v) const
16894 return v(ref_nested());
16898 template<typename V> bool decode(size_t index, V& v)
16903 case 1: type = 1; return v(ref_nested());
16904 ref_nested().clear();
16909 template<typename V> bool encode(size_t index, V& v) const
16911 if(index != type) {return false;} return v(ref_nested());
16918 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
16920 size_t get_index() const {return type;}
16921 bool is_unknown() const { return type == 1; }
16922 void clear() {type = 0;}
16923 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
16924 template<typename V> bool decode(V& v)
16927 if(!v(ref_nested())) return false;
16928 { type = 1; return true;}
16932 template<typename V> bool encode(V& v) const
16934 return v(ref_nested());
16938 template<typename V> bool decode(size_t index, V& v)
16943 case 1: type = 1; return v(ref_nested());
16944 ref_nested().clear();
16949 template<typename V> bool encode(size_t index, V& v) const
16951 if(index != type) {return false;} return v(ref_nested());
16958 struct Extension_t : asn::typefield<true>
16960 ~Extension_t() {clear();}
16961 size_t get_index() const {return type;}
16962 bool is_unknown() const { return type == 1; }
16965 type = 0; ref_nested().clear();
16967 template<typename V> static inline void enumerate(V& v)
16972 template<typename V> bool decode(size_t index, V& v)
16977 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
16982 template<typename V> bool encode(size_t index, V& v) const
16984 if(index != type) return false;
16992 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
16994 size_t get_index() const {return type;}
16995 bool is_unknown() const { return type == 1; }
16996 void clear() {type = 0;}
16997 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
16998 template<typename V> bool decode(V& v)
17001 if(!v(ref_nested())) return false;
17002 { type = 1; return true;}
17006 template<typename V> bool encode(V& v) const
17008 return v(ref_nested());
17012 template<typename V> bool decode(size_t index, V& v)
17017 case 1: type = 1; return v(ref_nested());
17018 ref_nested().clear();
17023 template<typename V> bool encode(size_t index, V& v) const
17025 if(index != type) {return false;} return v(ref_nested());
17035 EnhancedRNTP ::= SEQUENCE {
17036 enhancedRNTPBitmap BIT STRING (SIZE(12..8800, ...)),
17037 rNTP-High-Power-Threshold RNTP-Threshold,
17038 enhancedRNTPStartTime EnhancedRNTPStartTime OPTIONAL,
17039 iE-Extensions ProtocolExtensionContainer { {EnhancedRNTP-ExtIEs} } OPTIONAL,
17044 struct EnhancedRNTP : asn::sequence<4, 0, true, 2>
17046 static constexpr const char* name() {return "EnhancedRNTP";}
17047 using parent_t = asn::sequence<4, 0, true, 2>;
17048 struct enhancedRNTPBitmap_t : asn::bstring<>
17050 using constraint_t = asn::constraints<true,asn::span<12, 8800>>;
17051 static constexpr const char* name() {return "enhancedRNTPBitmap_t";}
17052 using parent_t = asn::bstring<>;
17056 enhancedRNTPBitmap_t& ref_enhancedRNTPBitmap() {return enhancedRNTPBitmap;}
17057 enhancedRNTPBitmap_t const& ref_enhancedRNTPBitmap() const {return enhancedRNTPBitmap;}
17058 struct rNTP_High_Power_Threshold_t : RNTP_Threshold
17060 static constexpr const char* name() {return "rNTP_High_Power_Threshold_t";}
17061 using parent_t = RNTP_Threshold;
17064 rNTP_High_Power_Threshold_t& ref_rNTP_High_Power_Threshold() {return rNTP_High_Power_Threshold;}
17065 rNTP_High_Power_Threshold_t const& ref_rNTP_High_Power_Threshold() const {return rNTP_High_Power_Threshold;}
17066 struct enhancedRNTPStartTime_t : EnhancedRNTPStartTime
17068 static constexpr const char* name() {return "enhancedRNTPStartTime_t";}
17069 using parent_t = EnhancedRNTPStartTime;
17070 static constexpr bool optional = true;
17073 enhancedRNTPStartTime_t& set_enhancedRNTPStartTime() { enhancedRNTPStartTime.setpresent(true); return enhancedRNTPStartTime;}
17074 enhancedRNTPStartTime_t const* get_enhancedRNTPStartTime() const {return enhancedRNTPStartTime.is_valid() ? &enhancedRNTPStartTime : nullptr;}
17075 struct iE_Extensions_t : ProtocolExtensionContainer<EnhancedRNTP_ExtIEs>
17077 static constexpr const char* name() {return "iE_Extensions_t";}
17078 using parent_t = ProtocolExtensionContainer<EnhancedRNTP_ExtIEs>;
17079 static constexpr bool optional = true;
17082 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17083 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17084 template<typename V> void decode(V& v)
17086 v(enhancedRNTPBitmap);
17087 v(rNTP_High_Power_Threshold);
17088 v(enhancedRNTPStartTime);
17092 template<typename V> void encode(V& v) const
17094 v(enhancedRNTPBitmap);
17095 v(rNTP_High_Power_Threshold);
17096 v(enhancedRNTPStartTime);
17102 enhancedRNTPBitmap.clear();
17103 rNTP_High_Power_Threshold.clear();
17104 enhancedRNTPStartTime.clear();
17105 iE_Extensions.clear();
17109 enhancedRNTPBitmap_t enhancedRNTPBitmap;
17110 rNTP_High_Power_Threshold_t rNTP_High_Power_Threshold;
17111 enhancedRNTPStartTime_t enhancedRNTPStartTime;
17112 iE_Extensions_t iE_Extensions;
17116 EventType ::= ENUMERATED{
17117 change-of-serving-cell,
17122 struct EventType : asn::enumerated<1, 0, true>
17124 static constexpr const char* name() {return "EventType";}
17125 using parent_t = asn::enumerated<1, 0, true>;
17127 change_of_serving_cell
17133 ExpectedActivityPeriod ::= INTEGER (1..30|40|50|60|80|100|120|150|180|181,...)
17136 struct ExpectedActivityPeriod : asn::integer<>
17138 using constraint_t = asn::constraints<true,asn::span<1, 30>,asn::one<40>,asn::one<50>,asn::one<60>,asn::one<80>,asn::one<100>,asn::one<120>,asn::one<150>,asn::one<180>,asn::one<181>>;
17139 static constexpr const char* name() {return "ExpectedActivityPeriod";}
17140 using parent_t = asn::integer<>;
17145 ExpectedHOInterval ::= ENUMERATED {
17146 sec15, sec30, sec60, sec90, sec120, sec180, long-time,
17151 struct ExpectedHOInterval : asn::enumerated<7, 0, true>
17153 static constexpr const char* name() {return "ExpectedHOInterval";}
17154 using parent_t = asn::enumerated<7, 0, true>;
17168 ExpectedIdlePeriod ::= INTEGER (1..30|40|50|60|80|100|120|150|180|181,...)
17171 struct ExpectedIdlePeriod : asn::integer<>
17173 using constraint_t = asn::constraints<true,asn::span<1, 30>,asn::one<40>,asn::one<50>,asn::one<60>,asn::one<80>,asn::one<100>,asn::one<120>,asn::one<150>,asn::one<180>,asn::one<181>>;
17174 static constexpr const char* name() {return "ExpectedIdlePeriod";}
17175 using parent_t = asn::integer<>;
17180 SourceOfUEActivityBehaviourInformation ::= ENUMERATED {
17181 subscription-information,
17187 struct SourceOfUEActivityBehaviourInformation : asn::enumerated<2, 0, true>
17189 static constexpr const char* name() {return "SourceOfUEActivityBehaviourInformation";}
17190 using parent_t = asn::enumerated<2, 0, true>;
17192 subscription_information
17199 ExpectedUEActivityBehaviour-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17204 struct ExpectedUEActivityBehaviour_ExtIEs
17206 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17208 size_t get_index() const {return type;}
17209 bool is_unknown() const { return type == 1; }
17210 void clear() {type = 0;}
17211 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17212 template<typename V> bool decode(V& v)
17215 if(!v(ref_nested())) return false;
17216 { type = 1; return true;}
17220 template<typename V> bool encode(V& v) const
17222 return v(ref_nested());
17226 template<typename V> bool decode(size_t index, V& v)
17231 case 1: type = 1; return v(ref_nested());
17232 ref_nested().clear();
17237 template<typename V> bool encode(size_t index, V& v) const
17239 if(index != type) {return false;} return v(ref_nested());
17246 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17248 size_t get_index() const {return type;}
17249 bool is_unknown() const { return type == 1; }
17250 void clear() {type = 0;}
17251 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17252 template<typename V> bool decode(V& v)
17255 if(!v(ref_nested())) return false;
17256 { type = 1; return true;}
17260 template<typename V> bool encode(V& v) const
17262 return v(ref_nested());
17266 template<typename V> bool decode(size_t index, V& v)
17271 case 1: type = 1; return v(ref_nested());
17272 ref_nested().clear();
17277 template<typename V> bool encode(size_t index, V& v) const
17279 if(index != type) {return false;} return v(ref_nested());
17286 struct Extension_t : asn::typefield<true>
17288 ~Extension_t() {clear();}
17289 size_t get_index() const {return type;}
17290 bool is_unknown() const { return type == 1; }
17293 type = 0; ref_nested().clear();
17295 template<typename V> static inline void enumerate(V& v)
17300 template<typename V> bool decode(size_t index, V& v)
17305 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
17310 template<typename V> bool encode(size_t index, V& v) const
17312 if(index != type) return false;
17320 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17322 size_t get_index() const {return type;}
17323 bool is_unknown() const { return type == 1; }
17324 void clear() {type = 0;}
17325 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17326 template<typename V> bool decode(V& v)
17329 if(!v(ref_nested())) return false;
17330 { type = 1; return true;}
17334 template<typename V> bool encode(V& v) const
17336 return v(ref_nested());
17340 template<typename V> bool decode(size_t index, V& v)
17345 case 1: type = 1; return v(ref_nested());
17346 ref_nested().clear();
17351 template<typename V> bool encode(size_t index, V& v) const
17353 if(index != type) {return false;} return v(ref_nested());
17363 ExpectedUEActivityBehaviour ::= SEQUENCE {
17364 expectedActivityPeriod ExpectedActivityPeriod OPTIONAL,
17365 expectedIdlePeriod ExpectedIdlePeriod OPTIONAL,
17366 sourceofUEActivityBehaviourInformation SourceOfUEActivityBehaviourInformation OPTIONAL,
17367 iE-Extensions ProtocolExtensionContainer { {ExpectedUEActivityBehaviour-ExtIEs} } OPTIONAL,
17372 struct ExpectedUEActivityBehaviour : asn::sequence<4, 0, true, 4>
17374 static constexpr const char* name() {return "ExpectedUEActivityBehaviour";}
17375 using parent_t = asn::sequence<4, 0, true, 4>;
17376 struct expectedActivityPeriod_t : ExpectedActivityPeriod
17378 static constexpr const char* name() {return "expectedActivityPeriod_t";}
17379 using parent_t = ExpectedActivityPeriod;
17380 static constexpr bool optional = true;
17383 expectedActivityPeriod_t& set_expectedActivityPeriod() { expectedActivityPeriod.setpresent(true); return expectedActivityPeriod;}
17384 expectedActivityPeriod_t const* get_expectedActivityPeriod() const {return expectedActivityPeriod.is_valid() ? &expectedActivityPeriod : nullptr;}
17385 struct expectedIdlePeriod_t : ExpectedIdlePeriod
17387 static constexpr const char* name() {return "expectedIdlePeriod_t";}
17388 using parent_t = ExpectedIdlePeriod;
17389 static constexpr bool optional = true;
17392 expectedIdlePeriod_t& set_expectedIdlePeriod() { expectedIdlePeriod.setpresent(true); return expectedIdlePeriod;}
17393 expectedIdlePeriod_t const* get_expectedIdlePeriod() const {return expectedIdlePeriod.is_valid() ? &expectedIdlePeriod : nullptr;}
17394 struct sourceofUEActivityBehaviourInformation_t : SourceOfUEActivityBehaviourInformation
17396 static constexpr const char* name() {return "sourceofUEActivityBehaviourInformation_t";}
17397 using parent_t = SourceOfUEActivityBehaviourInformation;
17398 static constexpr bool optional = true;
17401 sourceofUEActivityBehaviourInformation_t& set_sourceofUEActivityBehaviourInformation() { sourceofUEActivityBehaviourInformation.setpresent(true); return sourceofUEActivityBehaviourInformation;}
17402 sourceofUEActivityBehaviourInformation_t const* get_sourceofUEActivityBehaviourInformation() const {return sourceofUEActivityBehaviourInformation.is_valid() ? &sourceofUEActivityBehaviourInformation : nullptr;}
17403 struct iE_Extensions_t : ProtocolExtensionContainer<ExpectedUEActivityBehaviour_ExtIEs>
17405 static constexpr const char* name() {return "iE_Extensions_t";}
17406 using parent_t = ProtocolExtensionContainer<ExpectedUEActivityBehaviour_ExtIEs>;
17407 static constexpr bool optional = true;
17410 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17411 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17412 template<typename V> void decode(V& v)
17414 v(expectedActivityPeriod);
17415 v(expectedIdlePeriod);
17416 v(sourceofUEActivityBehaviourInformation);
17420 template<typename V> void encode(V& v) const
17422 v(expectedActivityPeriod);
17423 v(expectedIdlePeriod);
17424 v(sourceofUEActivityBehaviourInformation);
17430 expectedActivityPeriod.clear();
17431 expectedIdlePeriod.clear();
17432 sourceofUEActivityBehaviourInformation.clear();
17433 iE_Extensions.clear();
17437 expectedActivityPeriod_t expectedActivityPeriod;
17438 expectedIdlePeriod_t expectedIdlePeriod;
17439 sourceofUEActivityBehaviourInformation_t sourceofUEActivityBehaviourInformation;
17440 iE_Extensions_t iE_Extensions;
17444 ExpectedUEBehaviour-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17449 struct ExpectedUEBehaviour_ExtIEs
17451 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17453 size_t get_index() const {return type;}
17454 bool is_unknown() const { return type == 1; }
17455 void clear() {type = 0;}
17456 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17457 template<typename V> bool decode(V& v)
17460 if(!v(ref_nested())) return false;
17461 { type = 1; return true;}
17465 template<typename V> bool encode(V& v) const
17467 return v(ref_nested());
17471 template<typename V> bool decode(size_t index, V& v)
17476 case 1: type = 1; return v(ref_nested());
17477 ref_nested().clear();
17482 template<typename V> bool encode(size_t index, V& v) const
17484 if(index != type) {return false;} return v(ref_nested());
17491 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17493 size_t get_index() const {return type;}
17494 bool is_unknown() const { return type == 1; }
17495 void clear() {type = 0;}
17496 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17497 template<typename V> bool decode(V& v)
17500 if(!v(ref_nested())) return false;
17501 { type = 1; return true;}
17505 template<typename V> bool encode(V& v) const
17507 return v(ref_nested());
17511 template<typename V> bool decode(size_t index, V& v)
17516 case 1: type = 1; return v(ref_nested());
17517 ref_nested().clear();
17522 template<typename V> bool encode(size_t index, V& v) const
17524 if(index != type) {return false;} return v(ref_nested());
17531 struct Extension_t : asn::typefield<true>
17533 ~Extension_t() {clear();}
17534 size_t get_index() const {return type;}
17535 bool is_unknown() const { return type == 1; }
17538 type = 0; ref_nested().clear();
17540 template<typename V> static inline void enumerate(V& v)
17545 template<typename V> bool decode(size_t index, V& v)
17550 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
17555 template<typename V> bool encode(size_t index, V& v) const
17557 if(index != type) return false;
17565 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17567 size_t get_index() const {return type;}
17568 bool is_unknown() const { return type == 1; }
17569 void clear() {type = 0;}
17570 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17571 template<typename V> bool decode(V& v)
17574 if(!v(ref_nested())) return false;
17575 { type = 1; return true;}
17579 template<typename V> bool encode(V& v) const
17581 return v(ref_nested());
17585 template<typename V> bool decode(size_t index, V& v)
17590 case 1: type = 1; return v(ref_nested());
17591 ref_nested().clear();
17596 template<typename V> bool encode(size_t index, V& v) const
17598 if(index != type) {return false;} return v(ref_nested());
17608 ExpectedUEBehaviour ::= SEQUENCE {
17609 expectedActivity ExpectedUEActivityBehaviour OPTIONAL,
17610 expectedHOInterval ExpectedHOInterval OPTIONAL,
17611 iE-Extensions ProtocolExtensionContainer { {ExpectedUEBehaviour-ExtIEs} } OPTIONAL,
17616 struct ExpectedUEBehaviour : asn::sequence<3, 0, true, 3>
17618 static constexpr const char* name() {return "ExpectedUEBehaviour";}
17619 using parent_t = asn::sequence<3, 0, true, 3>;
17620 struct expectedActivity_t : ExpectedUEActivityBehaviour
17622 static constexpr const char* name() {return "expectedActivity_t";}
17623 using parent_t = ExpectedUEActivityBehaviour;
17624 static constexpr bool optional = true;
17627 expectedActivity_t& set_expectedActivity() { expectedActivity.setpresent(true); return expectedActivity;}
17628 expectedActivity_t const* get_expectedActivity() const {return expectedActivity.is_valid() ? &expectedActivity : nullptr;}
17629 struct expectedHOInterval_t : ExpectedHOInterval
17631 static constexpr const char* name() {return "expectedHOInterval_t";}
17632 using parent_t = ExpectedHOInterval;
17633 static constexpr bool optional = true;
17636 expectedHOInterval_t& set_expectedHOInterval() { expectedHOInterval.setpresent(true); return expectedHOInterval;}
17637 expectedHOInterval_t const* get_expectedHOInterval() const {return expectedHOInterval.is_valid() ? &expectedHOInterval : nullptr;}
17638 struct iE_Extensions_t : ProtocolExtensionContainer<ExpectedUEBehaviour_ExtIEs>
17640 static constexpr const char* name() {return "iE_Extensions_t";}
17641 using parent_t = ProtocolExtensionContainer<ExpectedUEBehaviour_ExtIEs>;
17642 static constexpr bool optional = true;
17645 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17646 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17647 template<typename V> void decode(V& v)
17649 v(expectedActivity);
17650 v(expectedHOInterval);
17654 template<typename V> void encode(V& v) const
17656 v(expectedActivity);
17657 v(expectedHOInterval);
17663 expectedActivity.clear();
17664 expectedHOInterval.clear();
17665 iE_Extensions.clear();
17669 expectedActivity_t expectedActivity;
17670 expectedHOInterval_t expectedHOInterval;
17671 iE_Extensions_t iE_Extensions;
17675 UL-InterferenceOverloadIndication-Item ::= ENUMERATED {
17677 medium-interference,
17683 struct UL_InterferenceOverloadIndication_Item : asn::enumerated<3, 0, true>
17685 static constexpr const char* name() {return "UL-InterferenceOverloadIndication-Item";}
17686 using parent_t = asn::enumerated<3, 0, true>;
17689 ,medium_interference
17696 UL-InterferenceOverloadIndication ::= SEQUENCE (SIZE(1..maxnoofPRBs)) OF UL-InterferenceOverloadIndication-Item
17699 struct UL_InterferenceOverloadIndication_elm : UL_InterferenceOverloadIndication_Item
17701 static constexpr const char* name() {return "UL_InterferenceOverloadIndication_elm";}
17702 using parent_t = UL_InterferenceOverloadIndication_Item;
17705 struct UL_InterferenceOverloadIndication : asn::sequenceof<UL_InterferenceOverloadIndication_elm>
17707 static constexpr const char* name() {return "UL-InterferenceOverloadIndication";}
17708 using parent_t = asn::sequenceof<UL_InterferenceOverloadIndication_elm>;
17709 using constraint_t = asn::constraints<false,asn::span<1, maxnoofPRBs >>;
17713 ExtendedULInterferenceOverloadInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
17718 struct ExtendedULInterferenceOverloadInfo_ExtIEs
17720 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
17722 size_t get_index() const {return type;}
17723 bool is_unknown() const { return type == 1; }
17724 void clear() {type = 0;}
17725 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
17726 template<typename V> bool decode(V& v)
17729 if(!v(ref_nested())) return false;
17730 { type = 1; return true;}
17734 template<typename V> bool encode(V& v) const
17736 return v(ref_nested());
17740 template<typename V> bool decode(size_t index, V& v)
17745 case 1: type = 1; return v(ref_nested());
17746 ref_nested().clear();
17751 template<typename V> bool encode(size_t index, V& v) const
17753 if(index != type) {return false;} return v(ref_nested());
17760 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
17762 size_t get_index() const {return type;}
17763 bool is_unknown() const { return type == 1; }
17764 void clear() {type = 0;}
17765 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
17766 template<typename V> bool decode(V& v)
17769 if(!v(ref_nested())) return false;
17770 { type = 1; return true;}
17774 template<typename V> bool encode(V& v) const
17776 return v(ref_nested());
17780 template<typename V> bool decode(size_t index, V& v)
17785 case 1: type = 1; return v(ref_nested());
17786 ref_nested().clear();
17791 template<typename V> bool encode(size_t index, V& v) const
17793 if(index != type) {return false;} return v(ref_nested());
17800 struct Extension_t : asn::typefield<true>
17802 ~Extension_t() {clear();}
17803 size_t get_index() const {return type;}
17804 bool is_unknown() const { return type == 1; }
17807 type = 0; ref_nested().clear();
17809 template<typename V> static inline void enumerate(V& v)
17814 template<typename V> bool decode(size_t index, V& v)
17819 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
17824 template<typename V> bool encode(size_t index, V& v) const
17826 if(index != type) return false;
17834 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
17836 size_t get_index() const {return type;}
17837 bool is_unknown() const { return type == 1; }
17838 void clear() {type = 0;}
17839 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
17840 template<typename V> bool decode(V& v)
17843 if(!v(ref_nested())) return false;
17844 { type = 1; return true;}
17848 template<typename V> bool encode(V& v) const
17850 return v(ref_nested());
17854 template<typename V> bool decode(size_t index, V& v)
17859 case 1: type = 1; return v(ref_nested());
17860 ref_nested().clear();
17865 template<typename V> bool encode(size_t index, V& v) const
17867 if(index != type) {return false;} return v(ref_nested());
17877 ExtendedULInterferenceOverloadInfo ::= SEQUENCE {
17878 associatedSubframes BIT STRING (SIZE (5)),
17879 extended-ul-InterferenceOverloadIndication UL-InterferenceOverloadIndication,
17880 iE-Extensions ProtocolExtensionContainer { {ExtendedULInterferenceOverloadInfo-ExtIEs} } OPTIONAL,
17885 struct ExtendedULInterferenceOverloadInfo : asn::sequence<3, 0, true, 1>
17887 static constexpr const char* name() {return "ExtendedULInterferenceOverloadInfo";}
17888 using parent_t = asn::sequence<3, 0, true, 1>;
17889 struct associatedSubframes_t : asn::bstring<>
17891 using constraint_t = asn::constraints<false,asn::one<5>>;
17892 static constexpr const char* name() {return "associatedSubframes_t";}
17893 using parent_t = asn::bstring<>;
17897 associatedSubframes_t& ref_associatedSubframes() {return associatedSubframes;}
17898 associatedSubframes_t const& ref_associatedSubframes() const {return associatedSubframes;}
17899 struct extended_ul_InterferenceOverloadIndication_t : UL_InterferenceOverloadIndication
17901 static constexpr const char* name() {return "extended_ul_InterferenceOverloadIndication_t";}
17902 using parent_t = UL_InterferenceOverloadIndication;
17905 extended_ul_InterferenceOverloadIndication_t& ref_extended_ul_InterferenceOverloadIndication() {return extended_ul_InterferenceOverloadIndication;}
17906 extended_ul_InterferenceOverloadIndication_t const& ref_extended_ul_InterferenceOverloadIndication() const {return extended_ul_InterferenceOverloadIndication;}
17907 struct iE_Extensions_t : ProtocolExtensionContainer<ExtendedULInterferenceOverloadInfo_ExtIEs>
17909 static constexpr const char* name() {return "iE_Extensions_t";}
17910 using parent_t = ProtocolExtensionContainer<ExtendedULInterferenceOverloadInfo_ExtIEs>;
17911 static constexpr bool optional = true;
17914 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
17915 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
17916 template<typename V> void decode(V& v)
17918 v(associatedSubframes);
17919 v(extended_ul_InterferenceOverloadIndication);
17923 template<typename V> void encode(V& v) const
17925 v(associatedSubframes);
17926 v(extended_ul_InterferenceOverloadIndication);
17932 associatedSubframes.clear();
17933 extended_ul_InterferenceOverloadIndication.clear();
17934 iE_Extensions.clear();
17938 associatedSubframes_t associatedSubframes;
17939 extended_ul_InterferenceOverloadIndication_t extended_ul_InterferenceOverloadIndication;
17940 iE_Extensions_t iE_Extensions;
17944 FiveGS-TAC ::= OCTET STRING (SIZE (3))
17947 struct FiveGS_TAC : asn::ostring<>
17949 using constraint_t = asn::constraints<false,asn::one<3>>;
17950 static constexpr const char* name() {return "FiveGS-TAC";}
17951 using parent_t = asn::ostring<>;
17956 ForbiddenInterRATs ::= ENUMERATED {
17968 struct ForbiddenInterRATs : asn::enumerated<6, 2, true>
17970 static constexpr const char* name() {return "ForbiddenInterRATs";}
17971 using parent_t = asn::enumerated<6, 2, true>;
17984 LAC ::= OCTET STRING (SIZE (2)) --(EXCEPT ('0000'H|'FFFE'H))
17987 struct LAC : asn::ostring<>
17989 using constraint_t = asn::constraints<false,asn::one<2>>;
17990 static constexpr const char* name() {return "LAC";}
17991 using parent_t = asn::ostring<>;
17996 ForbiddenLACs ::= SEQUENCE (SIZE(1..maxnoofForbLACs)) OF LAC
17999 struct ForbiddenLACs_elm : LAC
18001 static constexpr const char* name() {return "ForbiddenLACs_elm";}
18002 using parent_t = LAC;
18005 struct ForbiddenLACs : asn::sequenceof<ForbiddenLACs_elm>
18007 static constexpr const char* name() {return "ForbiddenLACs";}
18008 using parent_t = asn::sequenceof<ForbiddenLACs_elm>;
18009 using constraint_t = asn::constraints<false,asn::span<1, maxnoofForbLACs >>;
18013 ForbiddenLAs-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18018 struct ForbiddenLAs_Item_ExtIEs
18020 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18022 size_t get_index() const {return type;}
18023 bool is_unknown() const { return type == 1; }
18024 void clear() {type = 0;}
18025 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18026 template<typename V> bool decode(V& v)
18029 if(!v(ref_nested())) return false;
18030 { type = 1; return true;}
18034 template<typename V> bool encode(V& v) const
18036 return v(ref_nested());
18040 template<typename V> bool decode(size_t index, V& v)
18045 case 1: type = 1; return v(ref_nested());
18046 ref_nested().clear();
18051 template<typename V> bool encode(size_t index, V& v) const
18053 if(index != type) {return false;} return v(ref_nested());
18060 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18062 size_t get_index() const {return type;}
18063 bool is_unknown() const { return type == 1; }
18064 void clear() {type = 0;}
18065 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18066 template<typename V> bool decode(V& v)
18069 if(!v(ref_nested())) return false;
18070 { type = 1; return true;}
18074 template<typename V> bool encode(V& v) const
18076 return v(ref_nested());
18080 template<typename V> bool decode(size_t index, V& v)
18085 case 1: type = 1; return v(ref_nested());
18086 ref_nested().clear();
18091 template<typename V> bool encode(size_t index, V& v) const
18093 if(index != type) {return false;} return v(ref_nested());
18100 struct Extension_t : asn::typefield<true>
18102 ~Extension_t() {clear();}
18103 size_t get_index() const {return type;}
18104 bool is_unknown() const { return type == 1; }
18107 type = 0; ref_nested().clear();
18109 template<typename V> static inline void enumerate(V& v)
18114 template<typename V> bool decode(size_t index, V& v)
18119 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
18124 template<typename V> bool encode(size_t index, V& v) const
18126 if(index != type) return false;
18134 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18136 size_t get_index() const {return type;}
18137 bool is_unknown() const { return type == 1; }
18138 void clear() {type = 0;}
18139 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18140 template<typename V> bool decode(V& v)
18143 if(!v(ref_nested())) return false;
18144 { type = 1; return true;}
18148 template<typename V> bool encode(V& v) const
18150 return v(ref_nested());
18154 template<typename V> bool decode(size_t index, V& v)
18159 case 1: type = 1; return v(ref_nested());
18160 ref_nested().clear();
18165 template<typename V> bool encode(size_t index, V& v) const
18167 if(index != type) {return false;} return v(ref_nested());
18177 ForbiddenLAs-Item ::= SEQUENCE {
18178 pLMN-Identity PLMN-Identity,
18179 forbiddenLACs ForbiddenLACs,
18180 iE-Extensions ProtocolExtensionContainer { {ForbiddenLAs-Item-ExtIEs} } OPTIONAL,
18185 struct ForbiddenLAs_Item : asn::sequence<3, 0, true, 1>
18187 static constexpr const char* name() {return "ForbiddenLAs-Item";}
18188 using parent_t = asn::sequence<3, 0, true, 1>;
18189 struct pLMN_Identity_t : PLMN_Identity
18191 static constexpr const char* name() {return "pLMN_Identity_t";}
18192 using parent_t = PLMN_Identity;
18195 pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
18196 pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
18197 struct forbiddenLACs_t : ForbiddenLACs
18199 static constexpr const char* name() {return "forbiddenLACs_t";}
18200 using parent_t = ForbiddenLACs;
18203 forbiddenLACs_t& ref_forbiddenLACs() {return forbiddenLACs;}
18204 forbiddenLACs_t const& ref_forbiddenLACs() const {return forbiddenLACs;}
18205 struct iE_Extensions_t : ProtocolExtensionContainer<ForbiddenLAs_Item_ExtIEs>
18207 static constexpr const char* name() {return "iE_Extensions_t";}
18208 using parent_t = ProtocolExtensionContainer<ForbiddenLAs_Item_ExtIEs>;
18209 static constexpr bool optional = true;
18212 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18213 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18214 template<typename V> void decode(V& v)
18221 template<typename V> void encode(V& v) const
18230 pLMN_Identity.clear();
18231 forbiddenLACs.clear();
18232 iE_Extensions.clear();
18236 pLMN_Identity_t pLMN_Identity;
18237 forbiddenLACs_t forbiddenLACs;
18238 iE_Extensions_t iE_Extensions;
18242 ForbiddenLAs ::= SEQUENCE (SIZE(1..maxnoofEPLMNsPlusOne)) OF ForbiddenLAs-Item
18245 struct ForbiddenLAs_elm : ForbiddenLAs_Item
18247 static constexpr const char* name() {return "ForbiddenLAs_elm";}
18248 using parent_t = ForbiddenLAs_Item;
18251 struct ForbiddenLAs : asn::sequenceof<ForbiddenLAs_elm>
18253 static constexpr const char* name() {return "ForbiddenLAs";}
18254 using parent_t = asn::sequenceof<ForbiddenLAs_elm>;
18255 using constraint_t = asn::constraints<false,asn::span<1, maxnoofEPLMNsPlusOne >>;
18259 ForbiddenTACs ::= SEQUENCE (SIZE(1..maxnoofForbTACs)) OF TAC
18262 struct ForbiddenTACs_elm : TAC
18264 static constexpr const char* name() {return "ForbiddenTACs_elm";}
18265 using parent_t = TAC;
18268 struct ForbiddenTACs : asn::sequenceof<ForbiddenTACs_elm>
18270 static constexpr const char* name() {return "ForbiddenTACs";}
18271 using parent_t = asn::sequenceof<ForbiddenTACs_elm>;
18272 using constraint_t = asn::constraints<false,asn::span<1, maxnoofForbTACs >>;
18276 ForbiddenTAs-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18281 struct ForbiddenTAs_Item_ExtIEs
18283 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18285 size_t get_index() const {return type;}
18286 bool is_unknown() const { return type == 1; }
18287 void clear() {type = 0;}
18288 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18289 template<typename V> bool decode(V& v)
18292 if(!v(ref_nested())) return false;
18293 { type = 1; return true;}
18297 template<typename V> bool encode(V& v) const
18299 return v(ref_nested());
18303 template<typename V> bool decode(size_t index, V& v)
18308 case 1: type = 1; return v(ref_nested());
18309 ref_nested().clear();
18314 template<typename V> bool encode(size_t index, V& v) const
18316 if(index != type) {return false;} return v(ref_nested());
18323 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18325 size_t get_index() const {return type;}
18326 bool is_unknown() const { return type == 1; }
18327 void clear() {type = 0;}
18328 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18329 template<typename V> bool decode(V& v)
18332 if(!v(ref_nested())) return false;
18333 { type = 1; return true;}
18337 template<typename V> bool encode(V& v) const
18339 return v(ref_nested());
18343 template<typename V> bool decode(size_t index, V& v)
18348 case 1: type = 1; return v(ref_nested());
18349 ref_nested().clear();
18354 template<typename V> bool encode(size_t index, V& v) const
18356 if(index != type) {return false;} return v(ref_nested());
18363 struct Extension_t : asn::typefield<true>
18365 ~Extension_t() {clear();}
18366 size_t get_index() const {return type;}
18367 bool is_unknown() const { return type == 1; }
18370 type = 0; ref_nested().clear();
18372 template<typename V> static inline void enumerate(V& v)
18377 template<typename V> bool decode(size_t index, V& v)
18382 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
18387 template<typename V> bool encode(size_t index, V& v) const
18389 if(index != type) return false;
18397 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18399 size_t get_index() const {return type;}
18400 bool is_unknown() const { return type == 1; }
18401 void clear() {type = 0;}
18402 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18403 template<typename V> bool decode(V& v)
18406 if(!v(ref_nested())) return false;
18407 { type = 1; return true;}
18411 template<typename V> bool encode(V& v) const
18413 return v(ref_nested());
18417 template<typename V> bool decode(size_t index, V& v)
18422 case 1: type = 1; return v(ref_nested());
18423 ref_nested().clear();
18428 template<typename V> bool encode(size_t index, V& v) const
18430 if(index != type) {return false;} return v(ref_nested());
18440 ForbiddenTAs-Item ::= SEQUENCE {
18441 pLMN-Identity PLMN-Identity,
18442 forbiddenTACs ForbiddenTACs,
18443 iE-Extensions ProtocolExtensionContainer { {ForbiddenTAs-Item-ExtIEs} } OPTIONAL,
18448 struct ForbiddenTAs_Item : asn::sequence<3, 0, true, 1>
18450 static constexpr const char* name() {return "ForbiddenTAs-Item";}
18451 using parent_t = asn::sequence<3, 0, true, 1>;
18452 struct pLMN_Identity_t : PLMN_Identity
18454 static constexpr const char* name() {return "pLMN_Identity_t";}
18455 using parent_t = PLMN_Identity;
18458 pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
18459 pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
18460 struct forbiddenTACs_t : ForbiddenTACs
18462 static constexpr const char* name() {return "forbiddenTACs_t";}
18463 using parent_t = ForbiddenTACs;
18466 forbiddenTACs_t& ref_forbiddenTACs() {return forbiddenTACs;}
18467 forbiddenTACs_t const& ref_forbiddenTACs() const {return forbiddenTACs;}
18468 struct iE_Extensions_t : ProtocolExtensionContainer<ForbiddenTAs_Item_ExtIEs>
18470 static constexpr const char* name() {return "iE_Extensions_t";}
18471 using parent_t = ProtocolExtensionContainer<ForbiddenTAs_Item_ExtIEs>;
18472 static constexpr bool optional = true;
18475 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18476 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18477 template<typename V> void decode(V& v)
18484 template<typename V> void encode(V& v) const
18493 pLMN_Identity.clear();
18494 forbiddenTACs.clear();
18495 iE_Extensions.clear();
18499 pLMN_Identity_t pLMN_Identity;
18500 forbiddenTACs_t forbiddenTACs;
18501 iE_Extensions_t iE_Extensions;
18505 ForbiddenTAs ::= SEQUENCE (SIZE(1.. maxnoofEPLMNsPlusOne)) OF ForbiddenTAs-Item
18508 struct ForbiddenTAs_elm : ForbiddenTAs_Item
18510 static constexpr const char* name() {return "ForbiddenTAs_elm";}
18511 using parent_t = ForbiddenTAs_Item;
18514 struct ForbiddenTAs : asn::sequenceof<ForbiddenTAs_elm>
18516 static constexpr const char* name() {return "ForbiddenTAs";}
18517 using parent_t = asn::sequenceof<ForbiddenTAs_elm>;
18518 using constraint_t = asn::constraints<false,asn::span<1, maxnoofEPLMNsPlusOne >>;
18522 Fourframes ::= BIT STRING (SIZE (24))
18525 struct Fourframes : asn::bstring<>
18527 using constraint_t = asn::constraints<false,asn::one<24>>;
18528 static constexpr const char* name() {return "Fourframes";}
18529 using parent_t = asn::bstring<>;
18534 FreqBandIndicatorPriority ::= ENUMERATED {
18541 struct FreqBandIndicatorPriority : asn::enumerated<2, 0, true>
18543 static constexpr const char* name() {return "FreqBandIndicatorPriority";}
18544 using parent_t = asn::enumerated<2, 0, true>;
18553 SupportedSULFreqBandItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18558 struct SupportedSULFreqBandItem_ExtIEs
18560 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18562 size_t get_index() const {return type;}
18563 bool is_unknown() const { return type == 1; }
18564 void clear() {type = 0;}
18565 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18566 template<typename V> bool decode(V& v)
18569 if(!v(ref_nested())) return false;
18570 { type = 1; return true;}
18574 template<typename V> bool encode(V& v) const
18576 return v(ref_nested());
18580 template<typename V> bool decode(size_t index, V& v)
18585 case 1: type = 1; return v(ref_nested());
18586 ref_nested().clear();
18591 template<typename V> bool encode(size_t index, V& v) const
18593 if(index != type) {return false;} return v(ref_nested());
18600 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18602 size_t get_index() const {return type;}
18603 bool is_unknown() const { return type == 1; }
18604 void clear() {type = 0;}
18605 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18606 template<typename V> bool decode(V& v)
18609 if(!v(ref_nested())) return false;
18610 { type = 1; return true;}
18614 template<typename V> bool encode(V& v) const
18616 return v(ref_nested());
18620 template<typename V> bool decode(size_t index, V& v)
18625 case 1: type = 1; return v(ref_nested());
18626 ref_nested().clear();
18631 template<typename V> bool encode(size_t index, V& v) const
18633 if(index != type) {return false;} return v(ref_nested());
18640 struct Extension_t : asn::typefield<true>
18642 ~Extension_t() {clear();}
18643 size_t get_index() const {return type;}
18644 bool is_unknown() const { return type == 1; }
18647 type = 0; ref_nested().clear();
18649 template<typename V> static inline void enumerate(V& v)
18654 template<typename V> bool decode(size_t index, V& v)
18659 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
18664 template<typename V> bool encode(size_t index, V& v) const
18666 if(index != type) return false;
18674 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18676 size_t get_index() const {return type;}
18677 bool is_unknown() const { return type == 1; }
18678 void clear() {type = 0;}
18679 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18680 template<typename V> bool decode(V& v)
18683 if(!v(ref_nested())) return false;
18684 { type = 1; return true;}
18688 template<typename V> bool encode(V& v) const
18690 return v(ref_nested());
18694 template<typename V> bool decode(size_t index, V& v)
18699 case 1: type = 1; return v(ref_nested());
18700 ref_nested().clear();
18705 template<typename V> bool encode(size_t index, V& v) const
18707 if(index != type) {return false;} return v(ref_nested());
18717 SupportedSULFreqBandItem ::= SEQUENCE {
18718 freqBandIndicatorNr INTEGER (1..1024,...),
18719 iE-Extensions ProtocolExtensionContainer { {SupportedSULFreqBandItem-ExtIEs} } OPTIONAL,
18724 struct SupportedSULFreqBandItem : asn::sequence<2, 0, true, 1>
18726 static constexpr const char* name() {return "SupportedSULFreqBandItem";}
18727 using parent_t = asn::sequence<2, 0, true, 1>;
18728 struct freqBandIndicatorNr_t : asn::integer<>
18730 using constraint_t = asn::constraints<true,asn::span<1, 1024>>;
18731 static constexpr const char* name() {return "freqBandIndicatorNr_t";}
18732 using parent_t = asn::integer<>;
18736 freqBandIndicatorNr_t& ref_freqBandIndicatorNr() {return freqBandIndicatorNr;}
18737 freqBandIndicatorNr_t const& ref_freqBandIndicatorNr() const {return freqBandIndicatorNr;}
18738 struct iE_Extensions_t : ProtocolExtensionContainer<SupportedSULFreqBandItem_ExtIEs>
18740 static constexpr const char* name() {return "iE_Extensions_t";}
18741 using parent_t = ProtocolExtensionContainer<SupportedSULFreqBandItem_ExtIEs>;
18742 static constexpr bool optional = true;
18745 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18746 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18747 template<typename V> void decode(V& v)
18749 v(freqBandIndicatorNr);
18753 template<typename V> void encode(V& v) const
18755 v(freqBandIndicatorNr);
18761 freqBandIndicatorNr.clear();
18762 iE_Extensions.clear();
18766 freqBandIndicatorNr_t freqBandIndicatorNr;
18767 iE_Extensions_t iE_Extensions;
18771 FreqBandNrItem-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
18776 struct FreqBandNrItem_ExtIEs
18778 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
18780 size_t get_index() const {return type;}
18781 bool is_unknown() const { return type == 1; }
18782 void clear() {type = 0;}
18783 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
18784 template<typename V> bool decode(V& v)
18787 if(!v(ref_nested())) return false;
18788 { type = 1; return true;}
18792 template<typename V> bool encode(V& v) const
18794 return v(ref_nested());
18798 template<typename V> bool decode(size_t index, V& v)
18803 case 1: type = 1; return v(ref_nested());
18804 ref_nested().clear();
18809 template<typename V> bool encode(size_t index, V& v) const
18811 if(index != type) {return false;} return v(ref_nested());
18818 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
18820 size_t get_index() const {return type;}
18821 bool is_unknown() const { return type == 1; }
18822 void clear() {type = 0;}
18823 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
18824 template<typename V> bool decode(V& v)
18827 if(!v(ref_nested())) return false;
18828 { type = 1; return true;}
18832 template<typename V> bool encode(V& v) const
18834 return v(ref_nested());
18838 template<typename V> bool decode(size_t index, V& v)
18843 case 1: type = 1; return v(ref_nested());
18844 ref_nested().clear();
18849 template<typename V> bool encode(size_t index, V& v) const
18851 if(index != type) {return false;} return v(ref_nested());
18858 struct Extension_t : asn::typefield<true>
18860 ~Extension_t() {clear();}
18861 size_t get_index() const {return type;}
18862 bool is_unknown() const { return type == 1; }
18865 type = 0; ref_nested().clear();
18867 template<typename V> static inline void enumerate(V& v)
18872 template<typename V> bool decode(size_t index, V& v)
18877 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
18882 template<typename V> bool encode(size_t index, V& v) const
18884 if(index != type) return false;
18892 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
18894 size_t get_index() const {return type;}
18895 bool is_unknown() const { return type == 1; }
18896 void clear() {type = 0;}
18897 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
18898 template<typename V> bool decode(V& v)
18901 if(!v(ref_nested())) return false;
18902 { type = 1; return true;}
18906 template<typename V> bool encode(V& v) const
18908 return v(ref_nested());
18912 template<typename V> bool decode(size_t index, V& v)
18917 case 1: type = 1; return v(ref_nested());
18918 ref_nested().clear();
18923 template<typename V> bool encode(size_t index, V& v) const
18925 if(index != type) {return false;} return v(ref_nested());
18935 FreqBandNrItem ::= SEQUENCE {
18936 freqBandIndicatorNr INTEGER (1..1024,...),
18937 supportedSULBandList SEQUENCE (SIZE(0..maxnoofNrCellBands)) OF SupportedSULFreqBandItem,
18938 iE-Extensions ProtocolExtensionContainer { {FreqBandNrItem-ExtIEs} } OPTIONAL,
18943 struct FreqBandNrItem : asn::sequence<3, 0, true, 1>
18945 static constexpr const char* name() {return "FreqBandNrItem";}
18946 using parent_t = asn::sequence<3, 0, true, 1>;
18947 struct freqBandIndicatorNr_t : asn::integer<>
18949 using constraint_t = asn::constraints<true,asn::span<1, 1024>>;
18950 static constexpr const char* name() {return "freqBandIndicatorNr_t";}
18951 using parent_t = asn::integer<>;
18955 freqBandIndicatorNr_t& ref_freqBandIndicatorNr() {return freqBandIndicatorNr;}
18956 freqBandIndicatorNr_t const& ref_freqBandIndicatorNr() const {return freqBandIndicatorNr;}
18957 struct supportedSULBandList_t_elm : SupportedSULFreqBandItem
18959 static constexpr const char* name() {return "supportedSULBandList_t_elm";}
18960 using parent_t = SupportedSULFreqBandItem;
18963 struct supportedSULBandList_t : asn::sequenceof<supportedSULBandList_t_elm>
18965 static constexpr const char* name() {return "supportedSULBandList_t";}
18966 using parent_t = asn::sequenceof<supportedSULBandList_t_elm>;
18967 using constraint_t = asn::constraints<false,asn::span<0, maxnoofNrCellBands >>;
18970 supportedSULBandList_t& ref_supportedSULBandList() {return supportedSULBandList;}
18971 supportedSULBandList_t const& ref_supportedSULBandList() const {return supportedSULBandList;}
18972 struct iE_Extensions_t : ProtocolExtensionContainer<FreqBandNrItem_ExtIEs>
18974 static constexpr const char* name() {return "iE_Extensions_t";}
18975 using parent_t = ProtocolExtensionContainer<FreqBandNrItem_ExtIEs>;
18976 static constexpr bool optional = true;
18979 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
18980 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
18981 template<typename V> void decode(V& v)
18983 v(freqBandIndicatorNr);
18984 v(supportedSULBandList);
18988 template<typename V> void encode(V& v) const
18990 v(freqBandIndicatorNr);
18991 v(supportedSULBandList);
18997 freqBandIndicatorNr.clear();
18998 supportedSULBandList.clear();
18999 iE_Extensions.clear();
19003 freqBandIndicatorNr_t freqBandIndicatorNr;
19004 supportedSULBandList_t supportedSULBandList;
19005 iE_Extensions_t iE_Extensions;
19009 GNB-ID ::= CHOICE {
19010 gNB-ID BIT STRING (SIZE (22..32)),
19015 struct GNB_ID : asn::choice<1, 0, true>
19017 static constexpr const char* name() {return "GNB-ID";}
19018 using parent_t = asn::choice<1, 0, true>;
19019 index_type get_index() const {return index;}
19020 bool is_unknown() const {return index == 2;}
19021 void set_unknown() { set_index(2); }
19022 ~GNB_ID() {clear();}
19023 struct gNB_ID_t : asn::bstring<>
19025 using constraint_t = asn::constraints<false,asn::span<22, 32>>;
19026 static constexpr const char* name() {return "gNB_ID_t";}
19027 using parent_t = asn::bstring<>;
19033 switch(get_index())
19035 case 1: var.destroy<gNB_ID_t>(); break;
19040 template<typename V> bool decode(size_t idx, V& v)
19045 case 1: set_index(1); return v(var.build<gNB_ID_t>());
19050 template<typename V> bool encode(V& v) const
19052 switch(get_index())
19054 case 1: return v(var.as<gNB_ID_t>());
19058 template<typename V> static inline void enumerate(V& v)
19060 v.template operator()<gNB_ID_t>(1);
19063 gNB_ID_t& select_gNB_ID() { if(get_index() != 1) { clear(); set_index(1); return var.build<gNB_ID_t>();} return var.as<gNB_ID_t>();}
19064 gNB_ID_t const* get_gNB_ID() const { if(get_index() == 1) { return &var.as<gNB_ID_t>();} return nullptr; }
19066 void set_index(index_type i) {index = i; base::set();}
19069 char dummy1[sizeof(gNB_ID_t)];
19072 asn::variant<sizeof(union_type)> var;
19073 index_type index {0};
19076 GNBOverloadInformation ::= ENUMERATED {overloaded, not-overloaded, ...}
19079 struct GNBOverloadInformation : asn::enumerated<2, 0, true>
19081 static constexpr const char* name() {return "GNBOverloadInformation";}
19082 using parent_t = asn::enumerated<2, 0, true>;
19091 GTP-TEI ::= OCTET STRING (SIZE (4))
19094 struct GTP_TEI : asn::ostring<>
19096 using constraint_t = asn::constraints<false,asn::one<4>>;
19097 static constexpr const char* name() {return "GTP-TEI";}
19098 using parent_t = asn::ostring<>;
19103 TransportLayerAddress ::= BIT STRING (SIZE(1..160, ...))
19106 struct TransportLayerAddress : asn::bstring<>
19108 using constraint_t = asn::constraints<true,asn::span<1, 160>>;
19109 static constexpr const char* name() {return "TransportLayerAddress";}
19110 using parent_t = asn::bstring<>;
19115 GTPtunnelEndpoint-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19120 struct GTPtunnelEndpoint_ExtIEs
19122 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19124 size_t get_index() const {return type;}
19125 bool is_unknown() const { return type == 1; }
19126 void clear() {type = 0;}
19127 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19128 template<typename V> bool decode(V& v)
19131 if(!v(ref_nested())) return false;
19132 { type = 1; return true;}
19136 template<typename V> bool encode(V& v) const
19138 return v(ref_nested());
19142 template<typename V> bool decode(size_t index, V& v)
19147 case 1: type = 1; return v(ref_nested());
19148 ref_nested().clear();
19153 template<typename V> bool encode(size_t index, V& v) const
19155 if(index != type) {return false;} return v(ref_nested());
19162 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19164 size_t get_index() const {return type;}
19165 bool is_unknown() const { return type == 1; }
19166 void clear() {type = 0;}
19167 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19168 template<typename V> bool decode(V& v)
19171 if(!v(ref_nested())) return false;
19172 { type = 1; return true;}
19176 template<typename V> bool encode(V& v) const
19178 return v(ref_nested());
19182 template<typename V> bool decode(size_t index, V& v)
19187 case 1: type = 1; return v(ref_nested());
19188 ref_nested().clear();
19193 template<typename V> bool encode(size_t index, V& v) const
19195 if(index != type) {return false;} return v(ref_nested());
19202 struct Extension_t : asn::typefield<true>
19204 ~Extension_t() {clear();}
19205 size_t get_index() const {return type;}
19206 bool is_unknown() const { return type == 1; }
19209 type = 0; ref_nested().clear();
19211 template<typename V> static inline void enumerate(V& v)
19216 template<typename V> bool decode(size_t index, V& v)
19221 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19226 template<typename V> bool encode(size_t index, V& v) const
19228 if(index != type) return false;
19236 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19238 size_t get_index() const {return type;}
19239 bool is_unknown() const { return type == 1; }
19240 void clear() {type = 0;}
19241 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19242 template<typename V> bool decode(V& v)
19245 if(!v(ref_nested())) return false;
19246 { type = 1; return true;}
19250 template<typename V> bool encode(V& v) const
19252 return v(ref_nested());
19256 template<typename V> bool decode(size_t index, V& v)
19261 case 1: type = 1; return v(ref_nested());
19262 ref_nested().clear();
19267 template<typename V> bool encode(size_t index, V& v) const
19269 if(index != type) {return false;} return v(ref_nested());
19279 GTPtunnelEndpoint ::= SEQUENCE {
19280 transportLayerAddress TransportLayerAddress,
19282 iE-Extensions ProtocolExtensionContainer { {GTPtunnelEndpoint-ExtIEs} } OPTIONAL,
19287 struct GTPtunnelEndpoint : asn::sequence<3, 0, true, 1>
19289 static constexpr const char* name() {return "GTPtunnelEndpoint";}
19290 using parent_t = asn::sequence<3, 0, true, 1>;
19291 struct transportLayerAddress_t : TransportLayerAddress
19293 static constexpr const char* name() {return "transportLayerAddress_t";}
19294 using parent_t = TransportLayerAddress;
19297 transportLayerAddress_t& ref_transportLayerAddress() {return transportLayerAddress;}
19298 transportLayerAddress_t const& ref_transportLayerAddress() const {return transportLayerAddress;}
19299 struct gTP_TEID_t : GTP_TEI
19301 static constexpr const char* name() {return "gTP_TEID_t";}
19302 using parent_t = GTP_TEI;
19305 gTP_TEID_t& ref_gTP_TEID() {return gTP_TEID;}
19306 gTP_TEID_t const& ref_gTP_TEID() const {return gTP_TEID;}
19307 struct iE_Extensions_t : ProtocolExtensionContainer<GTPtunnelEndpoint_ExtIEs>
19309 static constexpr const char* name() {return "iE_Extensions_t";}
19310 using parent_t = ProtocolExtensionContainer<GTPtunnelEndpoint_ExtIEs>;
19311 static constexpr bool optional = true;
19314 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19315 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19316 template<typename V> void decode(V& v)
19318 v(transportLayerAddress);
19323 template<typename V> void encode(V& v) const
19325 v(transportLayerAddress);
19332 transportLayerAddress.clear();
19334 iE_Extensions.clear();
19338 transportLayerAddress_t transportLayerAddress;
19339 gTP_TEID_t gTP_TEID;
19340 iE_Extensions_t iE_Extensions;
19344 MME-Group-ID ::= OCTET STRING (SIZE (2))
19347 struct MME_Group_ID : asn::ostring<>
19349 using constraint_t = asn::constraints<false,asn::one<2>>;
19350 static constexpr const char* name() {return "MME-Group-ID";}
19351 using parent_t = asn::ostring<>;
19356 GU-Group-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19361 struct GU_Group_ID_ExtIEs
19363 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19365 size_t get_index() const {return type;}
19366 bool is_unknown() const { return type == 1; }
19367 void clear() {type = 0;}
19368 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19369 template<typename V> bool decode(V& v)
19372 if(!v(ref_nested())) return false;
19373 { type = 1; return true;}
19377 template<typename V> bool encode(V& v) const
19379 return v(ref_nested());
19383 template<typename V> bool decode(size_t index, V& v)
19388 case 1: type = 1; return v(ref_nested());
19389 ref_nested().clear();
19394 template<typename V> bool encode(size_t index, V& v) const
19396 if(index != type) {return false;} return v(ref_nested());
19403 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19405 size_t get_index() const {return type;}
19406 bool is_unknown() const { return type == 1; }
19407 void clear() {type = 0;}
19408 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19409 template<typename V> bool decode(V& v)
19412 if(!v(ref_nested())) return false;
19413 { type = 1; return true;}
19417 template<typename V> bool encode(V& v) const
19419 return v(ref_nested());
19423 template<typename V> bool decode(size_t index, V& v)
19428 case 1: type = 1; return v(ref_nested());
19429 ref_nested().clear();
19434 template<typename V> bool encode(size_t index, V& v) const
19436 if(index != type) {return false;} return v(ref_nested());
19443 struct Extension_t : asn::typefield<true>
19445 ~Extension_t() {clear();}
19446 size_t get_index() const {return type;}
19447 bool is_unknown() const { return type == 1; }
19450 type = 0; ref_nested().clear();
19452 template<typename V> static inline void enumerate(V& v)
19457 template<typename V> bool decode(size_t index, V& v)
19462 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19467 template<typename V> bool encode(size_t index, V& v) const
19469 if(index != type) return false;
19477 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19479 size_t get_index() const {return type;}
19480 bool is_unknown() const { return type == 1; }
19481 void clear() {type = 0;}
19482 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19483 template<typename V> bool decode(V& v)
19486 if(!v(ref_nested())) return false;
19487 { type = 1; return true;}
19491 template<typename V> bool encode(V& v) const
19493 return v(ref_nested());
19497 template<typename V> bool decode(size_t index, V& v)
19502 case 1: type = 1; return v(ref_nested());
19503 ref_nested().clear();
19508 template<typename V> bool encode(size_t index, V& v) const
19510 if(index != type) {return false;} return v(ref_nested());
19520 GU-Group-ID ::= SEQUENCE {
19521 pLMN-Identity PLMN-Identity,
19522 mME-Group-ID MME-Group-ID,
19523 iE-Extensions ProtocolExtensionContainer { {GU-Group-ID-ExtIEs} } OPTIONAL,
19528 struct GU_Group_ID : asn::sequence<3, 0, true, 1>
19530 static constexpr const char* name() {return "GU-Group-ID";}
19531 using parent_t = asn::sequence<3, 0, true, 1>;
19532 struct pLMN_Identity_t : PLMN_Identity
19534 static constexpr const char* name() {return "pLMN_Identity_t";}
19535 using parent_t = PLMN_Identity;
19538 pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
19539 pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
19540 struct mME_Group_ID_t : MME_Group_ID
19542 static constexpr const char* name() {return "mME_Group_ID_t";}
19543 using parent_t = MME_Group_ID;
19546 mME_Group_ID_t& ref_mME_Group_ID() {return mME_Group_ID;}
19547 mME_Group_ID_t const& ref_mME_Group_ID() const {return mME_Group_ID;}
19548 struct iE_Extensions_t : ProtocolExtensionContainer<GU_Group_ID_ExtIEs>
19550 static constexpr const char* name() {return "iE_Extensions_t";}
19551 using parent_t = ProtocolExtensionContainer<GU_Group_ID_ExtIEs>;
19552 static constexpr bool optional = true;
19555 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19556 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19557 template<typename V> void decode(V& v)
19564 template<typename V> void encode(V& v) const
19573 pLMN_Identity.clear();
19574 mME_Group_ID.clear();
19575 iE_Extensions.clear();
19579 pLMN_Identity_t pLMN_Identity;
19580 mME_Group_ID_t mME_Group_ID;
19581 iE_Extensions_t iE_Extensions;
19585 GUGroupIDList ::= SEQUENCE (SIZE (1..maxPools)) OF GU-Group-ID
19588 struct GUGroupIDList_elm : GU_Group_ID
19590 static constexpr const char* name() {return "GUGroupIDList_elm";}
19591 using parent_t = GU_Group_ID;
19594 struct GUGroupIDList : asn::sequenceof<GUGroupIDList_elm>
19596 static constexpr const char* name() {return "GUGroupIDList";}
19597 using parent_t = asn::sequenceof<GUGroupIDList_elm>;
19598 using constraint_t = asn::constraints<false,asn::span<1, maxPools >>;
19602 MME-Code ::= OCTET STRING (SIZE (1))
19605 struct MME_Code : asn::ostring<>
19607 using constraint_t = asn::constraints<false,asn::one<1>>;
19608 static constexpr const char* name() {return "MME-Code";}
19609 using parent_t = asn::ostring<>;
19614 GUMMEI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19619 struct GUMMEI_ExtIEs
19621 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19623 size_t get_index() const {return type;}
19624 bool is_unknown() const { return type == 1; }
19625 void clear() {type = 0;}
19626 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19627 template<typename V> bool decode(V& v)
19630 if(!v(ref_nested())) return false;
19631 { type = 1; return true;}
19635 template<typename V> bool encode(V& v) const
19637 return v(ref_nested());
19641 template<typename V> bool decode(size_t index, V& v)
19646 case 1: type = 1; return v(ref_nested());
19647 ref_nested().clear();
19652 template<typename V> bool encode(size_t index, V& v) const
19654 if(index != type) {return false;} return v(ref_nested());
19661 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19663 size_t get_index() const {return type;}
19664 bool is_unknown() const { return type == 1; }
19665 void clear() {type = 0;}
19666 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19667 template<typename V> bool decode(V& v)
19670 if(!v(ref_nested())) return false;
19671 { type = 1; return true;}
19675 template<typename V> bool encode(V& v) const
19677 return v(ref_nested());
19681 template<typename V> bool decode(size_t index, V& v)
19686 case 1: type = 1; return v(ref_nested());
19687 ref_nested().clear();
19692 template<typename V> bool encode(size_t index, V& v) const
19694 if(index != type) {return false;} return v(ref_nested());
19701 struct Extension_t : asn::typefield<true>
19703 ~Extension_t() {clear();}
19704 size_t get_index() const {return type;}
19705 bool is_unknown() const { return type == 1; }
19708 type = 0; ref_nested().clear();
19710 template<typename V> static inline void enumerate(V& v)
19715 template<typename V> bool decode(size_t index, V& v)
19720 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19725 template<typename V> bool encode(size_t index, V& v) const
19727 if(index != type) return false;
19735 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19737 size_t get_index() const {return type;}
19738 bool is_unknown() const { return type == 1; }
19739 void clear() {type = 0;}
19740 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19741 template<typename V> bool decode(V& v)
19744 if(!v(ref_nested())) return false;
19745 { type = 1; return true;}
19749 template<typename V> bool encode(V& v) const
19751 return v(ref_nested());
19755 template<typename V> bool decode(size_t index, V& v)
19760 case 1: type = 1; return v(ref_nested());
19761 ref_nested().clear();
19766 template<typename V> bool encode(size_t index, V& v) const
19768 if(index != type) {return false;} return v(ref_nested());
19778 GUMMEI ::= SEQUENCE {
19780 gU-Group-ID GU-Group-ID,
19782 iE-Extensions ProtocolExtensionContainer { {GUMMEI-ExtIEs} } OPTIONAL,
19787 struct GUMMEI : asn::sequence<3, 0, true, 1>
19789 static constexpr const char* name() {return "GUMMEI";}
19790 using parent_t = asn::sequence<3, 0, true, 1>;
19791 struct gU_Group_ID_t : GU_Group_ID
19793 static constexpr const char* name() {return "gU_Group_ID_t";}
19794 using parent_t = GU_Group_ID;
19797 gU_Group_ID_t& ref_gU_Group_ID() {return gU_Group_ID;}
19798 gU_Group_ID_t const& ref_gU_Group_ID() const {return gU_Group_ID;}
19799 struct mME_Code_t : MME_Code
19801 static constexpr const char* name() {return "mME_Code_t";}
19802 using parent_t = MME_Code;
19805 mME_Code_t& ref_mME_Code() {return mME_Code;}
19806 mME_Code_t const& ref_mME_Code() const {return mME_Code;}
19807 struct iE_Extensions_t : ProtocolExtensionContainer<GUMMEI_ExtIEs>
19809 static constexpr const char* name() {return "iE_Extensions_t";}
19810 using parent_t = ProtocolExtensionContainer<GUMMEI_ExtIEs>;
19811 static constexpr bool optional = true;
19814 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
19815 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
19816 template<typename V> void decode(V& v)
19823 template<typename V> void encode(V& v) const
19832 gU_Group_ID.clear();
19834 iE_Extensions.clear();
19838 gU_Group_ID_t gU_Group_ID;
19839 mME_Code_t mME_Code;
19840 iE_Extensions_t iE_Extensions;
19844 GlobalENB-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
19849 struct GlobalENB_ID_ExtIEs
19851 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
19853 size_t get_index() const {return type;}
19854 bool is_unknown() const { return type == 1; }
19855 void clear() {type = 0;}
19856 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
19857 template<typename V> bool decode(V& v)
19860 if(!v(ref_nested())) return false;
19861 { type = 1; return true;}
19865 template<typename V> bool encode(V& v) const
19867 return v(ref_nested());
19871 template<typename V> bool decode(size_t index, V& v)
19876 case 1: type = 1; return v(ref_nested());
19877 ref_nested().clear();
19882 template<typename V> bool encode(size_t index, V& v) const
19884 if(index != type) {return false;} return v(ref_nested());
19891 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
19893 size_t get_index() const {return type;}
19894 bool is_unknown() const { return type == 1; }
19895 void clear() {type = 0;}
19896 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
19897 template<typename V> bool decode(V& v)
19900 if(!v(ref_nested())) return false;
19901 { type = 1; return true;}
19905 template<typename V> bool encode(V& v) const
19907 return v(ref_nested());
19911 template<typename V> bool decode(size_t index, V& v)
19916 case 1: type = 1; return v(ref_nested());
19917 ref_nested().clear();
19922 template<typename V> bool encode(size_t index, V& v) const
19924 if(index != type) {return false;} return v(ref_nested());
19931 struct Extension_t : asn::typefield<true>
19933 ~Extension_t() {clear();}
19934 size_t get_index() const {return type;}
19935 bool is_unknown() const { return type == 1; }
19938 type = 0; ref_nested().clear();
19940 template<typename V> static inline void enumerate(V& v)
19945 template<typename V> bool decode(size_t index, V& v)
19950 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
19955 template<typename V> bool encode(size_t index, V& v) const
19957 if(index != type) return false;
19965 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
19967 size_t get_index() const {return type;}
19968 bool is_unknown() const { return type == 1; }
19969 void clear() {type = 0;}
19970 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
19971 template<typename V> bool decode(V& v)
19974 if(!v(ref_nested())) return false;
19975 { type = 1; return true;}
19979 template<typename V> bool encode(V& v) const
19981 return v(ref_nested());
19985 template<typename V> bool decode(size_t index, V& v)
19990 case 1: type = 1; return v(ref_nested());
19991 ref_nested().clear();
19996 template<typename V> bool encode(size_t index, V& v) const
19998 if(index != type) {return false;} return v(ref_nested());
20008 GlobalENB-ID ::= SEQUENCE {
20009 pLMN-Identity PLMN-Identity,
20011 iE-Extensions ProtocolExtensionContainer { {GlobalENB-ID-ExtIEs} } OPTIONAL,
20016 struct GlobalENB_ID : asn::sequence<3, 0, true, 1>
20018 static constexpr const char* name() {return "GlobalENB-ID";}
20019 using parent_t = asn::sequence<3, 0, true, 1>;
20020 struct pLMN_Identity_t : PLMN_Identity
20022 static constexpr const char* name() {return "pLMN_Identity_t";}
20023 using parent_t = PLMN_Identity;
20026 pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
20027 pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
20028 struct eNB_ID_t : ENB_ID
20030 static constexpr const char* name() {return "eNB_ID_t";}
20031 using parent_t = ENB_ID;
20034 eNB_ID_t& ref_eNB_ID() {return eNB_ID;}
20035 eNB_ID_t const& ref_eNB_ID() const {return eNB_ID;}
20036 struct iE_Extensions_t : ProtocolExtensionContainer<GlobalENB_ID_ExtIEs>
20038 static constexpr const char* name() {return "iE_Extensions_t";}
20039 using parent_t = ProtocolExtensionContainer<GlobalENB_ID_ExtIEs>;
20040 static constexpr bool optional = true;
20043 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20044 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20045 template<typename V> void decode(V& v)
20052 template<typename V> void encode(V& v) const
20061 pLMN_Identity.clear();
20063 iE_Extensions.clear();
20067 pLMN_Identity_t pLMN_Identity;
20069 iE_Extensions_t iE_Extensions;
20073 GlobalGNB-ID-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20078 struct GlobalGNB_ID_ExtIEs
20080 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20082 size_t get_index() const {return type;}
20083 bool is_unknown() const { return type == 1; }
20084 void clear() {type = 0;}
20085 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20086 template<typename V> bool decode(V& v)
20089 if(!v(ref_nested())) return false;
20090 { type = 1; return true;}
20094 template<typename V> bool encode(V& v) const
20096 return v(ref_nested());
20100 template<typename V> bool decode(size_t index, V& v)
20105 case 1: type = 1; return v(ref_nested());
20106 ref_nested().clear();
20111 template<typename V> bool encode(size_t index, V& v) const
20113 if(index != type) {return false;} return v(ref_nested());
20120 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20122 size_t get_index() const {return type;}
20123 bool is_unknown() const { return type == 1; }
20124 void clear() {type = 0;}
20125 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20126 template<typename V> bool decode(V& v)
20129 if(!v(ref_nested())) return false;
20130 { type = 1; return true;}
20134 template<typename V> bool encode(V& v) const
20136 return v(ref_nested());
20140 template<typename V> bool decode(size_t index, V& v)
20145 case 1: type = 1; return v(ref_nested());
20146 ref_nested().clear();
20151 template<typename V> bool encode(size_t index, V& v) const
20153 if(index != type) {return false;} return v(ref_nested());
20160 struct Extension_t : asn::typefield<true>
20162 ~Extension_t() {clear();}
20163 size_t get_index() const {return type;}
20164 bool is_unknown() const { return type == 1; }
20167 type = 0; ref_nested().clear();
20169 template<typename V> static inline void enumerate(V& v)
20174 template<typename V> bool decode(size_t index, V& v)
20179 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
20184 template<typename V> bool encode(size_t index, V& v) const
20186 if(index != type) return false;
20194 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20196 size_t get_index() const {return type;}
20197 bool is_unknown() const { return type == 1; }
20198 void clear() {type = 0;}
20199 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20200 template<typename V> bool decode(V& v)
20203 if(!v(ref_nested())) return false;
20204 { type = 1; return true;}
20208 template<typename V> bool encode(V& v) const
20210 return v(ref_nested());
20214 template<typename V> bool decode(size_t index, V& v)
20219 case 1: type = 1; return v(ref_nested());
20220 ref_nested().clear();
20225 template<typename V> bool encode(size_t index, V& v) const
20227 if(index != type) {return false;} return v(ref_nested());
20237 GlobalGNB-ID ::= SEQUENCE {
20238 pLMN-Identity PLMN-Identity,
20240 iE-Extensions ProtocolExtensionContainer { {GlobalGNB-ID-ExtIEs} } OPTIONAL,
20245 struct GlobalGNB_ID : asn::sequence<3, 0, true, 1>
20247 static constexpr const char* name() {return "GlobalGNB-ID";}
20248 using parent_t = asn::sequence<3, 0, true, 1>;
20249 struct pLMN_Identity_t : PLMN_Identity
20251 static constexpr const char* name() {return "pLMN_Identity_t";}
20252 using parent_t = PLMN_Identity;
20255 pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
20256 pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
20257 struct gNB_ID_t : GNB_ID
20259 static constexpr const char* name() {return "gNB_ID_t";}
20260 using parent_t = GNB_ID;
20263 gNB_ID_t& ref_gNB_ID() {return gNB_ID;}
20264 gNB_ID_t const& ref_gNB_ID() const {return gNB_ID;}
20265 struct iE_Extensions_t : ProtocolExtensionContainer<GlobalGNB_ID_ExtIEs>
20267 static constexpr const char* name() {return "iE_Extensions_t";}
20268 using parent_t = ProtocolExtensionContainer<GlobalGNB_ID_ExtIEs>;
20269 static constexpr bool optional = true;
20272 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20273 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20274 template<typename V> void decode(V& v)
20281 template<typename V> void encode(V& v) const
20290 pLMN_Identity.clear();
20292 iE_Extensions.clear();
20296 pLMN_Identity_t pLMN_Identity;
20298 iE_Extensions_t iE_Extensions;
20302 LoadIndicator ::= ENUMERATED {
20311 struct LoadIndicator : asn::enumerated<4, 0, true>
20313 static constexpr const char* name() {return "LoadIndicator";}
20314 using parent_t = asn::enumerated<4, 0, true>;
20325 HWLoadIndicator-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20330 struct HWLoadIndicator_ExtIEs
20332 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20334 size_t get_index() const {return type;}
20335 bool is_unknown() const { return type == 1; }
20336 void clear() {type = 0;}
20337 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20338 template<typename V> bool decode(V& v)
20341 if(!v(ref_nested())) return false;
20342 { type = 1; return true;}
20346 template<typename V> bool encode(V& v) const
20348 return v(ref_nested());
20352 template<typename V> bool decode(size_t index, V& v)
20357 case 1: type = 1; return v(ref_nested());
20358 ref_nested().clear();
20363 template<typename V> bool encode(size_t index, V& v) const
20365 if(index != type) {return false;} return v(ref_nested());
20372 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20374 size_t get_index() const {return type;}
20375 bool is_unknown() const { return type == 1; }
20376 void clear() {type = 0;}
20377 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20378 template<typename V> bool decode(V& v)
20381 if(!v(ref_nested())) return false;
20382 { type = 1; return true;}
20386 template<typename V> bool encode(V& v) const
20388 return v(ref_nested());
20392 template<typename V> bool decode(size_t index, V& v)
20397 case 1: type = 1; return v(ref_nested());
20398 ref_nested().clear();
20403 template<typename V> bool encode(size_t index, V& v) const
20405 if(index != type) {return false;} return v(ref_nested());
20412 struct Extension_t : asn::typefield<true>
20414 ~Extension_t() {clear();}
20415 size_t get_index() const {return type;}
20416 bool is_unknown() const { return type == 1; }
20419 type = 0; ref_nested().clear();
20421 template<typename V> static inline void enumerate(V& v)
20426 template<typename V> bool decode(size_t index, V& v)
20431 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
20436 template<typename V> bool encode(size_t index, V& v) const
20438 if(index != type) return false;
20446 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20448 size_t get_index() const {return type;}
20449 bool is_unknown() const { return type == 1; }
20450 void clear() {type = 0;}
20451 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20452 template<typename V> bool decode(V& v)
20455 if(!v(ref_nested())) return false;
20456 { type = 1; return true;}
20460 template<typename V> bool encode(V& v) const
20462 return v(ref_nested());
20466 template<typename V> bool decode(size_t index, V& v)
20471 case 1: type = 1; return v(ref_nested());
20472 ref_nested().clear();
20477 template<typename V> bool encode(size_t index, V& v) const
20479 if(index != type) {return false;} return v(ref_nested());
20489 HWLoadIndicator ::= SEQUENCE {
20490 dLHWLoadIndicator LoadIndicator,
20491 uLHWLoadIndicator LoadIndicator,
20492 iE-Extensions ProtocolExtensionContainer { {HWLoadIndicator-ExtIEs} } OPTIONAL,
20497 struct HWLoadIndicator : asn::sequence<3, 0, true, 1>
20499 static constexpr const char* name() {return "HWLoadIndicator";}
20500 using parent_t = asn::sequence<3, 0, true, 1>;
20501 struct dLHWLoadIndicator_t : LoadIndicator
20503 static constexpr const char* name() {return "dLHWLoadIndicator_t";}
20504 using parent_t = LoadIndicator;
20507 dLHWLoadIndicator_t& ref_dLHWLoadIndicator() {return dLHWLoadIndicator;}
20508 dLHWLoadIndicator_t const& ref_dLHWLoadIndicator() const {return dLHWLoadIndicator;}
20509 struct uLHWLoadIndicator_t : LoadIndicator
20511 static constexpr const char* name() {return "uLHWLoadIndicator_t";}
20512 using parent_t = LoadIndicator;
20515 uLHWLoadIndicator_t& ref_uLHWLoadIndicator() {return uLHWLoadIndicator;}
20516 uLHWLoadIndicator_t const& ref_uLHWLoadIndicator() const {return uLHWLoadIndicator;}
20517 struct iE_Extensions_t : ProtocolExtensionContainer<HWLoadIndicator_ExtIEs>
20519 static constexpr const char* name() {return "iE_Extensions_t";}
20520 using parent_t = ProtocolExtensionContainer<HWLoadIndicator_ExtIEs>;
20521 static constexpr bool optional = true;
20524 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20525 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20526 template<typename V> void decode(V& v)
20528 v(dLHWLoadIndicator);
20529 v(uLHWLoadIndicator);
20533 template<typename V> void encode(V& v) const
20535 v(dLHWLoadIndicator);
20536 v(uLHWLoadIndicator);
20542 dLHWLoadIndicator.clear();
20543 uLHWLoadIndicator.clear();
20544 iE_Extensions.clear();
20548 dLHWLoadIndicator_t dLHWLoadIndicator;
20549 uLHWLoadIndicator_t uLHWLoadIndicator;
20550 iE_Extensions_t iE_Extensions;
20554 HandoverReportType ::= ENUMERATED {
20562 struct HandoverReportType : asn::enumerated<3, 1, true>
20564 static constexpr const char* name() {return "HandoverReportType";}
20565 using parent_t = asn::enumerated<3, 1, true>;
20575 NRrestrictioninEPSasSecondaryRAT ::= ENUMERATED {
20576 nRrestrictedinEPSasSecondaryRAT,
20581 struct NRrestrictioninEPSasSecondaryRAT : asn::enumerated<1, 0, true>
20583 static constexpr const char* name() {return "NRrestrictioninEPSasSecondaryRAT";}
20584 using parent_t = asn::enumerated<1, 0, true>;
20586 nRrestrictedinEPSasSecondaryRAT
20592 NRrestrictionin5GS ::= ENUMERATED {
20598 struct NRrestrictionin5GS : asn::enumerated<1, 0, true>
20600 static constexpr const char* name() {return "NRrestrictionin5GS";}
20601 using parent_t = asn::enumerated<1, 0, true>;
20609 HandoverRestrictionList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
20610 { ID id-NRrestrictioninEPSasSecondaryRAT CRITICALITY ignore EXTENSION NRrestrictioninEPSasSecondaryRAT PRESENCE optional}|
20611 { ID id-CNTypeRestrictions CRITICALITY ignore EXTENSION CNTypeRestrictions PRESENCE optional}|
20612 { ID id-NRrestrictionin5GS CRITICALITY ignore EXTENSION NRrestrictionin5GS PRESENCE optional},
20617 struct HandoverRestrictionList_ExtIEs
20619 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
20621 size_t get_index() const {return type;}
20622 bool is_unknown() const { return type == 4; }
20623 void clear() {type = 0;}
20624 void select_id_NRrestrictioninEPSasSecondaryRAT() { set(id_NRrestrictioninEPSasSecondaryRAT); type=1;}
20625 void select_id_CNTypeRestrictions() { set(id_CNTypeRestrictions); type=2;}
20626 void select_id_NRrestrictionin5GS() { set(id_NRrestrictionin5GS); type=3;}
20627 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
20628 template<typename V> bool decode(V& v)
20631 if(!v(ref_nested())) return false;
20632 if(equal(id_NRrestrictioninEPSasSecondaryRAT)) { type = 1; return true; }
20633 else if(equal(id_CNTypeRestrictions)) { type = 2; return true; }
20634 else if(equal(id_NRrestrictionin5GS)) { type = 3; return true; }
20635 else { type = 4; return true;}
20639 template<typename V> bool encode(V& v) const
20641 return v(ref_nested());
20645 template<typename V> bool decode(size_t index, V& v)
20650 case 1: type = 1; if(v(ref_nested())) { return equal(id_NRrestrictioninEPSasSecondaryRAT);} return false;
20651 case 2: type = 2; if(v(ref_nested())) { return equal(id_CNTypeRestrictions);} return false;
20652 case 3: type = 3; if(v(ref_nested())) { return equal(id_NRrestrictionin5GS);} return false;
20653 case 4: type = 4; return v(ref_nested());
20654 ref_nested().clear();
20659 template<typename V> bool encode(size_t index, V& v) const
20661 if(index != type) {return false;} return v(ref_nested());
20668 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
20670 size_t get_index() const {return type;}
20671 bool is_unknown() const { return type == 4; }
20672 void clear() {type = 0;}
20673 void select_id_NRrestrictioninEPSasSecondaryRAT() { set(ignore); type=1;}
20674 void select_id_CNTypeRestrictions() { set(ignore); type=2;}
20675 void select_id_NRrestrictionin5GS() { set(ignore); type=3;}
20676 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
20677 template<typename V> bool decode(V& v)
20680 if(!v(ref_nested())) return false;
20681 if(equal(ignore)) { type = 1; return true; }
20682 else if(equal(ignore)) { type = 2; return true; }
20683 else if(equal(ignore)) { type = 3; return true; }
20684 else { type = 4; return true;}
20688 template<typename V> bool encode(V& v) const
20690 return v(ref_nested());
20694 template<typename V> bool decode(size_t index, V& v)
20699 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
20700 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
20701 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
20702 case 4: type = 4; return v(ref_nested());
20703 ref_nested().clear();
20708 template<typename V> bool encode(size_t index, V& v) const
20710 if(index != type) {return false;} return v(ref_nested());
20717 struct Extension_t : asn::typefield<true>
20719 ~Extension_t() {clear();}
20720 size_t get_index() const {return type;}
20721 NRrestrictioninEPSasSecondaryRAT& select_id_NRrestrictioninEPSasSecondaryRAT() { return set<NRrestrictioninEPSasSecondaryRAT>(1); }
20722 NRrestrictioninEPSasSecondaryRAT const* get_id_NRrestrictioninEPSasSecondaryRAT() const { return get<NRrestrictioninEPSasSecondaryRAT>(1); }
20723 CNTypeRestrictions& select_id_CNTypeRestrictions() { return set<CNTypeRestrictions>(2); }
20724 CNTypeRestrictions const* get_id_CNTypeRestrictions() const { return get<CNTypeRestrictions>(2); }
20725 NRrestrictionin5GS& select_id_NRrestrictionin5GS() { return set<NRrestrictionin5GS>(3); }
20726 NRrestrictionin5GS const* get_id_NRrestrictionin5GS() const { return get<NRrestrictionin5GS>(3); }
20727 bool is_unknown() const { return type == 4; }
20732 case 1: var.destroy<NRrestrictioninEPSasSecondaryRAT>(); break;
20733 case 2: var.destroy<CNTypeRestrictions>(); break;
20734 case 3: var.destroy<NRrestrictionin5GS>(); break;
20736 type = 0; ref_nested().clear();
20738 template<typename V> static inline void enumerate(V& v)
20740 v.template operator()<NRrestrictioninEPSasSecondaryRAT>(1);
20741 v.template operator()<CNTypeRestrictions>(2);
20742 v.template operator()<NRrestrictionin5GS>(3);
20746 template<typename V> bool decode(size_t index, V& v)
20751 case 1: v(select_id_NRrestrictioninEPSasSecondaryRAT()); return true;
20752 case 2: v(select_id_CNTypeRestrictions()); return true;
20753 case 3: v(select_id_NRrestrictionin5GS()); return true;
20754 case 4: if(type != 4) {clear(); asn::base::set();} type = 4; return true;
20759 template<typename V> bool encode(size_t index, V& v) const
20761 if(index != type) return false;
20764 case 1: v(var.as<NRrestrictioninEPSasSecondaryRAT>()); return true;
20765 case 2: v(var.as<CNTypeRestrictions>()); return true;
20766 case 3: v(var.as<NRrestrictionin5GS>()); return true;
20772 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
20773 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
20776 char dummy1[sizeof(CNTypeRestrictions)];
20777 char dummy2[sizeof(NRrestrictionin5GS)];
20778 char dummy3[sizeof(NRrestrictioninEPSasSecondaryRAT)];
20781 asn::variant<sizeof(union_type)> var;
20785 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
20787 size_t get_index() const {return type;}
20788 bool is_unknown() const { return type == 4; }
20789 void clear() {type = 0;}
20790 void select_id_NRrestrictioninEPSasSecondaryRAT() { set(optional); type=1;}
20791 void select_id_CNTypeRestrictions() { set(optional); type=2;}
20792 void select_id_NRrestrictionin5GS() { set(optional); type=3;}
20793 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
20794 template<typename V> bool decode(V& v)
20797 if(!v(ref_nested())) return false;
20798 if(equal(optional)) { type = 1; return true; }
20799 else if(equal(optional)) { type = 2; return true; }
20800 else if(equal(optional)) { type = 3; return true; }
20801 else { type = 4; return true;}
20805 template<typename V> bool encode(V& v) const
20807 return v(ref_nested());
20811 template<typename V> bool decode(size_t index, V& v)
20816 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
20817 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
20818 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
20819 case 4: type = 4; return v(ref_nested());
20820 ref_nested().clear();
20825 template<typename V> bool encode(size_t index, V& v) const
20827 if(index != type) {return false;} return v(ref_nested());
20837 HandoverRestrictionList ::= SEQUENCE {
20838 servingPLMN PLMN-Identity,
20839 equivalentPLMNs EPLMNs OPTIONAL,
20840 forbiddenTAs ForbiddenTAs OPTIONAL,
20841 forbiddenLAs ForbiddenLAs OPTIONAL,
20842 forbiddenInterRATs ForbiddenInterRATs OPTIONAL,
20843 iE-Extensions ProtocolExtensionContainer { {HandoverRestrictionList-ExtIEs} } OPTIONAL,
20848 struct HandoverRestrictionList : asn::sequence<6, 0, true, 5>
20850 static constexpr const char* name() {return "HandoverRestrictionList";}
20851 using parent_t = asn::sequence<6, 0, true, 5>;
20852 struct servingPLMN_t : PLMN_Identity
20854 static constexpr const char* name() {return "servingPLMN_t";}
20855 using parent_t = PLMN_Identity;
20858 servingPLMN_t& ref_servingPLMN() {return servingPLMN;}
20859 servingPLMN_t const& ref_servingPLMN() const {return servingPLMN;}
20860 struct equivalentPLMNs_t : EPLMNs
20862 static constexpr const char* name() {return "equivalentPLMNs_t";}
20863 using parent_t = EPLMNs;
20864 static constexpr bool optional = true;
20867 equivalentPLMNs_t& set_equivalentPLMNs() { equivalentPLMNs.setpresent(true); return equivalentPLMNs;}
20868 equivalentPLMNs_t const* get_equivalentPLMNs() const {return equivalentPLMNs.is_valid() ? &equivalentPLMNs : nullptr;}
20869 struct forbiddenTAs_t : ForbiddenTAs
20871 static constexpr const char* name() {return "forbiddenTAs_t";}
20872 using parent_t = ForbiddenTAs;
20873 static constexpr bool optional = true;
20876 forbiddenTAs_t& set_forbiddenTAs() { forbiddenTAs.setpresent(true); return forbiddenTAs;}
20877 forbiddenTAs_t const* get_forbiddenTAs() const {return forbiddenTAs.is_valid() ? &forbiddenTAs : nullptr;}
20878 struct forbiddenLAs_t : ForbiddenLAs
20880 static constexpr const char* name() {return "forbiddenLAs_t";}
20881 using parent_t = ForbiddenLAs;
20882 static constexpr bool optional = true;
20885 forbiddenLAs_t& set_forbiddenLAs() { forbiddenLAs.setpresent(true); return forbiddenLAs;}
20886 forbiddenLAs_t const* get_forbiddenLAs() const {return forbiddenLAs.is_valid() ? &forbiddenLAs : nullptr;}
20887 struct forbiddenInterRATs_t : ForbiddenInterRATs
20889 static constexpr const char* name() {return "forbiddenInterRATs_t";}
20890 using parent_t = ForbiddenInterRATs;
20891 static constexpr bool optional = true;
20894 forbiddenInterRATs_t& set_forbiddenInterRATs() { forbiddenInterRATs.setpresent(true); return forbiddenInterRATs;}
20895 forbiddenInterRATs_t const* get_forbiddenInterRATs() const {return forbiddenInterRATs.is_valid() ? &forbiddenInterRATs : nullptr;}
20896 struct iE_Extensions_t : ProtocolExtensionContainer<HandoverRestrictionList_ExtIEs>
20898 static constexpr const char* name() {return "iE_Extensions_t";}
20899 using parent_t = ProtocolExtensionContainer<HandoverRestrictionList_ExtIEs>;
20900 static constexpr bool optional = true;
20903 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
20904 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
20905 template<typename V> void decode(V& v)
20908 v(equivalentPLMNs);
20911 v(forbiddenInterRATs);
20915 template<typename V> void encode(V& v) const
20918 v(equivalentPLMNs);
20921 v(forbiddenInterRATs);
20927 servingPLMN.clear();
20928 equivalentPLMNs.clear();
20929 forbiddenTAs.clear();
20930 forbiddenLAs.clear();
20931 forbiddenInterRATs.clear();
20932 iE_Extensions.clear();
20936 servingPLMN_t servingPLMN;
20937 equivalentPLMNs_t equivalentPLMNs;
20938 forbiddenTAs_t forbiddenTAs;
20939 forbiddenLAs_t forbiddenLAs;
20940 forbiddenInterRATs_t forbiddenInterRATs;
20941 iE_Extensions_t iE_Extensions;
20945 IntegrityProtectionAlgorithms ::= BIT STRING (SIZE (16, ...))
20948 struct IntegrityProtectionAlgorithms : asn::bstring<>
20950 using constraint_t = asn::constraints<true,asn::one<16>>;
20951 static constexpr const char* name() {return "IntegrityProtectionAlgorithms";}
20952 using parent_t = asn::bstring<>;
20957 InterfacesToTrace ::= BIT STRING (SIZE (8))
20960 struct InterfacesToTrace : asn::bstring<>
20962 using constraint_t = asn::constraints<false,asn::one<8>>;
20963 static constexpr const char* name() {return "InterfacesToTrace";}
20964 using parent_t = asn::bstring<>;
20969 InvokeIndication ::= ENUMERATED{
20972 naics-information-start,
20973 naics-information-stop
20977 struct InvokeIndication : asn::enumerated<3, 2, true>
20979 static constexpr const char* name() {return "InvokeIndication";}
20980 using parent_t = asn::enumerated<3, 2, true>;
20983 ,naics_information_start
20984 ,naics_information_stop
20990 LCID ::= INTEGER(1..32, ...)
20993 struct LCID : asn::integer<>
20995 using constraint_t = asn::constraints<true,asn::span<1, 32>>;
20996 static constexpr const char* name() {return "LCID";}
20997 using parent_t = asn::integer<>;
21002 LHN-ID ::= OCTET STRING(SIZE (32..256))
21005 struct LHN_ID : asn::ostring<>
21007 using constraint_t = asn::constraints<false,asn::span<32, 256>>;
21008 static constexpr const char* name() {return "LHN-ID";}
21009 using parent_t = asn::ostring<>;
21014 Time-UE-StayedInCell ::= INTEGER (0..4095)
21017 struct Time_UE_StayedInCell : asn::integer<>
21019 using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
21020 static constexpr const char* name() {return "Time-UE-StayedInCell";}
21021 using parent_t = asn::integer<>;
21026 Time-UE-StayedInCell-EnhancedGranularity ::= INTEGER (0..40950)
21029 struct Time_UE_StayedInCell_EnhancedGranularity : asn::integer<>
21031 using constraint_t = asn::constraints<false,asn::span<0, 40950>>;
21032 static constexpr const char* name() {return "Time-UE-StayedInCell-EnhancedGranularity";}
21033 using parent_t = asn::integer<>;
21038 LastVisitedEUTRANCellInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
21039 -- Extension for Rel-11 to support enhanced granularity for time UE stayed in cell --
21040 { ID id-Time-UE-StayedInCell-EnhancedGranularity CRITICALITY ignore EXTENSION Time-UE-StayedInCell-EnhancedGranularity PRESENCE optional}|
21041 { ID id-HO-cause CRITICALITY ignore EXTENSION Cause PRESENCE optional},
21046 struct LastVisitedEUTRANCellInformation_ExtIEs
21048 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21050 size_t get_index() const {return type;}
21051 bool is_unknown() const { return type == 3; }
21052 void clear() {type = 0;}
21053 void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(id_Time_UE_StayedInCell_EnhancedGranularity); type=1;}
21054 void select_id_HO_cause() { set(id_HO_cause); type=2;}
21055 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21056 template<typename V> bool decode(V& v)
21059 if(!v(ref_nested())) return false;
21060 if(equal(id_Time_UE_StayedInCell_EnhancedGranularity)) { type = 1; return true; }
21061 else if(equal(id_HO_cause)) { type = 2; return true; }
21062 else { type = 3; return true;}
21066 template<typename V> bool encode(V& v) const
21068 return v(ref_nested());
21072 template<typename V> bool decode(size_t index, V& v)
21077 case 1: type = 1; if(v(ref_nested())) { return equal(id_Time_UE_StayedInCell_EnhancedGranularity);} return false;
21078 case 2: type = 2; if(v(ref_nested())) { return equal(id_HO_cause);} return false;
21079 case 3: type = 3; return v(ref_nested());
21080 ref_nested().clear();
21085 template<typename V> bool encode(size_t index, V& v) const
21087 if(index != type) {return false;} return v(ref_nested());
21094 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
21096 size_t get_index() const {return type;}
21097 bool is_unknown() const { return type == 3; }
21098 void clear() {type = 0;}
21099 void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(ignore); type=1;}
21100 void select_id_HO_cause() { set(ignore); type=2;}
21101 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
21102 template<typename V> bool decode(V& v)
21105 if(!v(ref_nested())) return false;
21106 if(equal(ignore)) { type = 1; return true; }
21107 else if(equal(ignore)) { type = 2; return true; }
21108 else { type = 3; return true;}
21112 template<typename V> bool encode(V& v) const
21114 return v(ref_nested());
21118 template<typename V> bool decode(size_t index, V& v)
21123 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
21124 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
21125 case 3: type = 3; return v(ref_nested());
21126 ref_nested().clear();
21131 template<typename V> bool encode(size_t index, V& v) const
21133 if(index != type) {return false;} return v(ref_nested());
21140 struct Extension_t : asn::typefield<true>
21142 ~Extension_t() {clear();}
21143 size_t get_index() const {return type;}
21144 Time_UE_StayedInCell_EnhancedGranularity& select_id_Time_UE_StayedInCell_EnhancedGranularity() { return set<Time_UE_StayedInCell_EnhancedGranularity>(1); }
21145 Time_UE_StayedInCell_EnhancedGranularity const* get_id_Time_UE_StayedInCell_EnhancedGranularity() const { return get<Time_UE_StayedInCell_EnhancedGranularity>(1); }
21146 Cause& select_id_HO_cause() { return set<Cause>(2); }
21147 Cause const* get_id_HO_cause() const { return get<Cause>(2); }
21148 bool is_unknown() const { return type == 3; }
21153 case 1: var.destroy<Time_UE_StayedInCell_EnhancedGranularity>(); break;
21154 case 2: var.destroy<Cause>(); break;
21156 type = 0; ref_nested().clear();
21158 template<typename V> static inline void enumerate(V& v)
21160 v.template operator()<Time_UE_StayedInCell_EnhancedGranularity>(1);
21161 v.template operator()<Cause>(2);
21165 template<typename V> bool decode(size_t index, V& v)
21170 case 1: v(select_id_Time_UE_StayedInCell_EnhancedGranularity()); return true;
21171 case 2: v(select_id_HO_cause()); return true;
21172 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
21177 template<typename V> bool encode(size_t index, V& v) const
21179 if(index != type) return false;
21182 case 1: v(var.as<Time_UE_StayedInCell_EnhancedGranularity>()); return true;
21183 case 2: v(var.as<Cause>()); return true;
21189 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
21190 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
21193 char dummy1[sizeof(Cause)];
21194 char dummy2[sizeof(Time_UE_StayedInCell_EnhancedGranularity)];
21197 asn::variant<sizeof(union_type)> var;
21201 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
21203 size_t get_index() const {return type;}
21204 bool is_unknown() const { return type == 3; }
21205 void clear() {type = 0;}
21206 void select_id_Time_UE_StayedInCell_EnhancedGranularity() { set(optional); type=1;}
21207 void select_id_HO_cause() { set(optional); type=2;}
21208 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
21209 template<typename V> bool decode(V& v)
21212 if(!v(ref_nested())) return false;
21213 if(equal(optional)) { type = 1; return true; }
21214 else if(equal(optional)) { type = 2; return true; }
21215 else { type = 3; return true;}
21219 template<typename V> bool encode(V& v) const
21221 return v(ref_nested());
21225 template<typename V> bool decode(size_t index, V& v)
21230 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
21231 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
21232 case 3: type = 3; return v(ref_nested());
21233 ref_nested().clear();
21238 template<typename V> bool encode(size_t index, V& v) const
21240 if(index != type) {return false;} return v(ref_nested());
21250 LastVisitedEUTRANCellInformation ::= SEQUENCE {
21251 global-Cell-ID ECGI,
21253 time-UE-StayedInCell Time-UE-StayedInCell,
21254 iE-Extensions ProtocolExtensionContainer { {LastVisitedEUTRANCellInformation-ExtIEs} } OPTIONAL,
21259 struct LastVisitedEUTRANCellInformation : asn::sequence<4, 0, true, 1>
21261 static constexpr const char* name() {return "LastVisitedEUTRANCellInformation";}
21262 using parent_t = asn::sequence<4, 0, true, 1>;
21263 struct global_Cell_ID_t : ECGI
21265 static constexpr const char* name() {return "global_Cell_ID_t";}
21266 using parent_t = ECGI;
21269 global_Cell_ID_t& ref_global_Cell_ID() {return global_Cell_ID;}
21270 global_Cell_ID_t const& ref_global_Cell_ID() const {return global_Cell_ID;}
21271 struct cellType_t : CellType
21273 static constexpr const char* name() {return "cellType_t";}
21274 using parent_t = CellType;
21277 cellType_t& ref_cellType() {return cellType;}
21278 cellType_t const& ref_cellType() const {return cellType;}
21279 struct time_UE_StayedInCell_t : Time_UE_StayedInCell
21281 static constexpr const char* name() {return "time_UE_StayedInCell_t";}
21282 using parent_t = Time_UE_StayedInCell;
21285 time_UE_StayedInCell_t& ref_time_UE_StayedInCell() {return time_UE_StayedInCell;}
21286 time_UE_StayedInCell_t const& ref_time_UE_StayedInCell() const {return time_UE_StayedInCell;}
21287 struct iE_Extensions_t : ProtocolExtensionContainer<LastVisitedEUTRANCellInformation_ExtIEs>
21289 static constexpr const char* name() {return "iE_Extensions_t";}
21290 using parent_t = ProtocolExtensionContainer<LastVisitedEUTRANCellInformation_ExtIEs>;
21291 static constexpr bool optional = true;
21294 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
21295 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
21296 template<typename V> void decode(V& v)
21300 v(time_UE_StayedInCell);
21304 template<typename V> void encode(V& v) const
21308 v(time_UE_StayedInCell);
21314 global_Cell_ID.clear();
21316 time_UE_StayedInCell.clear();
21317 iE_Extensions.clear();
21321 global_Cell_ID_t global_Cell_ID;
21322 cellType_t cellType;
21323 time_UE_StayedInCell_t time_UE_StayedInCell;
21324 iE_Extensions_t iE_Extensions;
21328 LastVisitedUTRANCellInformation ::= OCTET STRING
21331 struct LastVisitedUTRANCellInformation : asn::ostring<>
21333 static constexpr const char* name() {return "LastVisitedUTRANCellInformation";}
21334 using parent_t = asn::ostring<>;
21339 LastVisitedGERANCellInformation ::= CHOICE {
21345 struct LastVisitedGERANCellInformation : asn::choice<1, 0, true>
21347 static constexpr const char* name() {return "LastVisitedGERANCellInformation";}
21348 using parent_t = asn::choice<1, 0, true>;
21349 index_type get_index() const {return index;}
21350 bool is_unknown() const {return index == 2;}
21351 void set_unknown() { set_index(2); }
21352 ~LastVisitedGERANCellInformation() {clear();}
21353 struct undefined_t : asn::nulltype
21355 static constexpr const char* name() {return "undefined_t";}
21356 using parent_t = asn::nulltype;
21361 switch(get_index())
21363 case 1: var.destroy<undefined_t>(); break;
21368 template<typename V> bool decode(size_t idx, V& v)
21373 case 1: set_index(1); return v(var.build<undefined_t>());
21378 template<typename V> bool encode(V& v) const
21380 switch(get_index())
21382 case 1: return v(var.as<undefined_t>());
21386 template<typename V> static inline void enumerate(V& v)
21388 v.template operator()<undefined_t>(1);
21391 undefined_t& select_undefined() { if(get_index() != 1) { clear(); set_index(1); return var.build<undefined_t>();} return var.as<undefined_t>();}
21392 undefined_t const* get_undefined() const { if(get_index() == 1) { return &var.as<undefined_t>();} return nullptr; }
21394 void set_index(index_type i) {index = i; base::set();}
21397 char dummy1[sizeof(undefined_t)];
21400 asn::variant<sizeof(union_type)> var;
21401 index_type index {0};
21404 LastVisitedNGRANCellInformation ::= OCTET STRING
21407 struct LastVisitedNGRANCellInformation : asn::ostring<>
21409 static constexpr const char* name() {return "LastVisitedNGRANCellInformation";}
21410 using parent_t = asn::ostring<>;
21415 LastVisitedCell-Item ::= CHOICE {
21416 e-UTRAN-Cell LastVisitedEUTRANCellInformation,
21417 uTRAN-Cell LastVisitedUTRANCellInformation,
21418 gERAN-Cell LastVisitedGERANCellInformation,
21420 nG-RAN-Cell LastVisitedNGRANCellInformation
21424 struct LastVisitedCell_Item : asn::choice<4, 1, true>
21426 static constexpr const char* name() {return "LastVisitedCell-Item";}
21427 using parent_t = asn::choice<4, 1, true>;
21428 index_type get_index() const {return index;}
21429 bool is_unknown() const {return index == 5;}
21430 void set_unknown() { set_index(5); }
21431 ~LastVisitedCell_Item() {clear();}
21432 struct e_UTRAN_Cell_t : LastVisitedEUTRANCellInformation
21434 static constexpr const char* name() {return "e_UTRAN_Cell_t";}
21435 using parent_t = LastVisitedEUTRANCellInformation;
21438 struct uTRAN_Cell_t : LastVisitedUTRANCellInformation
21440 static constexpr const char* name() {return "uTRAN_Cell_t";}
21441 using parent_t = LastVisitedUTRANCellInformation;
21444 struct gERAN_Cell_t : LastVisitedGERANCellInformation
21446 static constexpr const char* name() {return "gERAN_Cell_t";}
21447 using parent_t = LastVisitedGERANCellInformation;
21450 struct nG_RAN_Cell_t : LastVisitedNGRANCellInformation
21452 static constexpr const char* name() {return "nG_RAN_Cell_t";}
21453 using parent_t = LastVisitedNGRANCellInformation;
21458 switch(get_index())
21460 case 1: var.destroy<e_UTRAN_Cell_t>(); break;
21461 case 2: var.destroy<uTRAN_Cell_t>(); break;
21462 case 3: var.destroy<gERAN_Cell_t>(); break;
21463 case 4: var.destroy<nG_RAN_Cell_t>(); break;
21468 template<typename V> bool decode(size_t idx, V& v)
21473 case 1: set_index(1); return v(var.build<e_UTRAN_Cell_t>());
21474 case 2: set_index(2); return v(var.build<uTRAN_Cell_t>());
21475 case 3: set_index(3); return v(var.build<gERAN_Cell_t>());
21476 case 4: set_index(4); return v(var.build<nG_RAN_Cell_t>());
21481 template<typename V> bool encode(V& v) const
21483 switch(get_index())
21485 case 1: return v(var.as<e_UTRAN_Cell_t>());
21486 case 2: return v(var.as<uTRAN_Cell_t>());
21487 case 3: return v(var.as<gERAN_Cell_t>());
21488 case 4: return v(var.as<nG_RAN_Cell_t>());
21492 template<typename V> static inline void enumerate(V& v)
21494 v.template operator()<e_UTRAN_Cell_t>(1);
21495 v.template operator()<uTRAN_Cell_t>(2);
21496 v.template operator()<gERAN_Cell_t>(3);
21497 v.template operator()<nG_RAN_Cell_t>(4);
21500 e_UTRAN_Cell_t& select_e_UTRAN_Cell() { if(get_index() != 1) { clear(); set_index(1); return var.build<e_UTRAN_Cell_t>();} return var.as<e_UTRAN_Cell_t>();}
21501 e_UTRAN_Cell_t const* get_e_UTRAN_Cell() const { if(get_index() == 1) { return &var.as<e_UTRAN_Cell_t>();} return nullptr; }
21502 uTRAN_Cell_t& select_uTRAN_Cell() { if(get_index() != 2) { clear(); set_index(2); return var.build<uTRAN_Cell_t>();} return var.as<uTRAN_Cell_t>();}
21503 uTRAN_Cell_t const* get_uTRAN_Cell() const { if(get_index() == 2) { return &var.as<uTRAN_Cell_t>();} return nullptr; }
21504 gERAN_Cell_t& select_gERAN_Cell() { if(get_index() != 3) { clear(); set_index(3); return var.build<gERAN_Cell_t>();} return var.as<gERAN_Cell_t>();}
21505 gERAN_Cell_t const* get_gERAN_Cell() const { if(get_index() == 3) { return &var.as<gERAN_Cell_t>();} return nullptr; }
21506 nG_RAN_Cell_t& select_nG_RAN_Cell() { if(get_index() != 4) { clear(); set_index(4); return var.build<nG_RAN_Cell_t>();} return var.as<nG_RAN_Cell_t>();}
21507 nG_RAN_Cell_t const* get_nG_RAN_Cell() const { if(get_index() == 4) { return &var.as<nG_RAN_Cell_t>();} return nullptr; }
21509 void set_index(index_type i) {index = i; base::set();}
21512 char dummy1[sizeof(e_UTRAN_Cell_t)];
21513 char dummy2[sizeof(uTRAN_Cell_t)];
21514 char dummy3[sizeof(gERAN_Cell_t)];
21515 char dummy4[sizeof(nG_RAN_Cell_t)];
21518 asn::variant<sizeof(union_type)> var;
21519 index_type index {0};
21522 Links-to-log ::= ENUMERATED {uplink, downlink, both-uplink-and-downlink, ...}
21525 struct Links_to_log : asn::enumerated<3, 0, true>
21527 static constexpr const char* name() {return "Links-to-log";}
21528 using parent_t = asn::enumerated<3, 0, true>;
21532 ,both_uplink_and_downlink
21538 ReportArea ::= ENUMERATED{
21544 struct ReportArea : asn::enumerated<1, 0, true>
21546 static constexpr const char* name() {return "ReportArea";}
21547 using parent_t = asn::enumerated<1, 0, true>;
21555 LocationReportingInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::={
21560 struct LocationReportingInformation_ExtIEs
21562 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21564 size_t get_index() const {return type;}
21565 bool is_unknown() const { return type == 1; }
21566 void clear() {type = 0;}
21567 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21568 template<typename V> bool decode(V& v)
21571 if(!v(ref_nested())) return false;
21572 { type = 1; return true;}
21576 template<typename V> bool encode(V& v) const
21578 return v(ref_nested());
21582 template<typename V> bool decode(size_t index, V& v)
21587 case 1: type = 1; return v(ref_nested());
21588 ref_nested().clear();
21593 template<typename V> bool encode(size_t index, V& v) const
21595 if(index != type) {return false;} return v(ref_nested());
21602 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
21604 size_t get_index() const {return type;}
21605 bool is_unknown() const { return type == 1; }
21606 void clear() {type = 0;}
21607 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
21608 template<typename V> bool decode(V& v)
21611 if(!v(ref_nested())) return false;
21612 { type = 1; return true;}
21616 template<typename V> bool encode(V& v) const
21618 return v(ref_nested());
21622 template<typename V> bool decode(size_t index, V& v)
21627 case 1: type = 1; return v(ref_nested());
21628 ref_nested().clear();
21633 template<typename V> bool encode(size_t index, V& v) const
21635 if(index != type) {return false;} return v(ref_nested());
21642 struct Extension_t : asn::typefield<true>
21644 ~Extension_t() {clear();}
21645 size_t get_index() const {return type;}
21646 bool is_unknown() const { return type == 1; }
21649 type = 0; ref_nested().clear();
21651 template<typename V> static inline void enumerate(V& v)
21656 template<typename V> bool decode(size_t index, V& v)
21661 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
21666 template<typename V> bool encode(size_t index, V& v) const
21668 if(index != type) return false;
21676 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
21678 size_t get_index() const {return type;}
21679 bool is_unknown() const { return type == 1; }
21680 void clear() {type = 0;}
21681 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
21682 template<typename V> bool decode(V& v)
21685 if(!v(ref_nested())) return false;
21686 { type = 1; return true;}
21690 template<typename V> bool encode(V& v) const
21692 return v(ref_nested());
21696 template<typename V> bool decode(size_t index, V& v)
21701 case 1: type = 1; return v(ref_nested());
21702 ref_nested().clear();
21707 template<typename V> bool encode(size_t index, V& v) const
21709 if(index != type) {return false;} return v(ref_nested());
21719 LocationReportingInformation ::= SEQUENCE {
21720 eventType EventType,
21721 reportArea ReportArea,
21722 iE-Extensions ProtocolExtensionContainer { {LocationReportingInformation-ExtIEs} } OPTIONAL,
21727 struct LocationReportingInformation : asn::sequence<3, 0, true, 1>
21729 static constexpr const char* name() {return "LocationReportingInformation";}
21730 using parent_t = asn::sequence<3, 0, true, 1>;
21731 struct eventType_t : EventType
21733 static constexpr const char* name() {return "eventType_t";}
21734 using parent_t = EventType;
21737 eventType_t& ref_eventType() {return eventType;}
21738 eventType_t const& ref_eventType() const {return eventType;}
21739 struct reportArea_t : ReportArea
21741 static constexpr const char* name() {return "reportArea_t";}
21742 using parent_t = ReportArea;
21745 reportArea_t& ref_reportArea() {return reportArea;}
21746 reportArea_t const& ref_reportArea() const {return reportArea;}
21747 struct iE_Extensions_t : ProtocolExtensionContainer<LocationReportingInformation_ExtIEs>
21749 static constexpr const char* name() {return "iE_Extensions_t";}
21750 using parent_t = ProtocolExtensionContainer<LocationReportingInformation_ExtIEs>;
21751 static constexpr bool optional = true;
21754 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
21755 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
21756 template<typename V> void decode(V& v)
21763 template<typename V> void encode(V& v) const
21773 reportArea.clear();
21774 iE_Extensions.clear();
21778 eventType_t eventType;
21779 reportArea_t reportArea;
21780 iE_Extensions_t iE_Extensions;
21784 ReportIntervalMDT ::= ENUMERATED {ms120, ms240, ms480, ms640, ms1024, ms2048, ms5120, ms10240, min1, min6, min12, min30, min60}
21787 struct ReportIntervalMDT : asn::enumerated<13, 0, false>
21789 static constexpr const char* name() {return "ReportIntervalMDT";}
21790 using parent_t = asn::enumerated<13, 0, false>;
21810 ReportAmountMDT ::= ENUMERATED{r1, r2, r4, r8, r16, r32, r64, rinfinity}
21813 struct ReportAmountMDT : asn::enumerated<8, 0, false>
21815 static constexpr const char* name() {return "ReportAmountMDT";}
21816 using parent_t = asn::enumerated<8, 0, false>;
21831 M1PeriodicReporting-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
21836 struct M1PeriodicReporting_ExtIEs
21838 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
21840 size_t get_index() const {return type;}
21841 bool is_unknown() const { return type == 1; }
21842 void clear() {type = 0;}
21843 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
21844 template<typename V> bool decode(V& v)
21847 if(!v(ref_nested())) return false;
21848 { type = 1; return true;}
21852 template<typename V> bool encode(V& v) const
21854 return v(ref_nested());
21858 template<typename V> bool decode(size_t index, V& v)
21863 case 1: type = 1; return v(ref_nested());
21864 ref_nested().clear();
21869 template<typename V> bool encode(size_t index, V& v) const
21871 if(index != type) {return false;} return v(ref_nested());
21878 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
21880 size_t get_index() const {return type;}
21881 bool is_unknown() const { return type == 1; }
21882 void clear() {type = 0;}
21883 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
21884 template<typename V> bool decode(V& v)
21887 if(!v(ref_nested())) return false;
21888 { type = 1; return true;}
21892 template<typename V> bool encode(V& v) const
21894 return v(ref_nested());
21898 template<typename V> bool decode(size_t index, V& v)
21903 case 1: type = 1; return v(ref_nested());
21904 ref_nested().clear();
21909 template<typename V> bool encode(size_t index, V& v) const
21911 if(index != type) {return false;} return v(ref_nested());
21918 struct Extension_t : asn::typefield<true>
21920 ~Extension_t() {clear();}
21921 size_t get_index() const {return type;}
21922 bool is_unknown() const { return type == 1; }
21925 type = 0; ref_nested().clear();
21927 template<typename V> static inline void enumerate(V& v)
21932 template<typename V> bool decode(size_t index, V& v)
21937 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
21942 template<typename V> bool encode(size_t index, V& v) const
21944 if(index != type) return false;
21952 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
21954 size_t get_index() const {return type;}
21955 bool is_unknown() const { return type == 1; }
21956 void clear() {type = 0;}
21957 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
21958 template<typename V> bool decode(V& v)
21961 if(!v(ref_nested())) return false;
21962 { type = 1; return true;}
21966 template<typename V> bool encode(V& v) const
21968 return v(ref_nested());
21972 template<typename V> bool decode(size_t index, V& v)
21977 case 1: type = 1; return v(ref_nested());
21978 ref_nested().clear();
21983 template<typename V> bool encode(size_t index, V& v) const
21985 if(index != type) {return false;} return v(ref_nested());
21995 M1PeriodicReporting ::= SEQUENCE {
21996 reportInterval ReportIntervalMDT,
21997 reportAmount ReportAmountMDT,
21998 iE-Extensions ProtocolExtensionContainer { {M1PeriodicReporting-ExtIEs} } OPTIONAL,
22003 struct M1PeriodicReporting : asn::sequence<3, 0, true, 1>
22005 static constexpr const char* name() {return "M1PeriodicReporting";}
22006 using parent_t = asn::sequence<3, 0, true, 1>;
22007 struct reportInterval_t : ReportIntervalMDT
22009 static constexpr const char* name() {return "reportInterval_t";}
22010 using parent_t = ReportIntervalMDT;
22013 reportInterval_t& ref_reportInterval() {return reportInterval;}
22014 reportInterval_t const& ref_reportInterval() const {return reportInterval;}
22015 struct reportAmount_t : ReportAmountMDT
22017 static constexpr const char* name() {return "reportAmount_t";}
22018 using parent_t = ReportAmountMDT;
22021 reportAmount_t& ref_reportAmount() {return reportAmount;}
22022 reportAmount_t const& ref_reportAmount() const {return reportAmount;}
22023 struct iE_Extensions_t : ProtocolExtensionContainer<M1PeriodicReporting_ExtIEs>
22025 static constexpr const char* name() {return "iE_Extensions_t";}
22026 using parent_t = ProtocolExtensionContainer<M1PeriodicReporting_ExtIEs>;
22027 static constexpr bool optional = true;
22030 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22031 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22032 template<typename V> void decode(V& v)
22039 template<typename V> void encode(V& v) const
22048 reportInterval.clear();
22049 reportAmount.clear();
22050 iE_Extensions.clear();
22054 reportInterval_t reportInterval;
22055 reportAmount_t reportAmount;
22056 iE_Extensions_t iE_Extensions;
22060 M1ReportingTrigger::= ENUMERATED{
22064 a2eventtriggered-periodic
22068 struct M1ReportingTrigger : asn::enumerated<3, 1, true>
22070 static constexpr const char* name() {return "M1ReportingTrigger";}
22071 using parent_t = asn::enumerated<3, 1, true>;
22075 ,a2eventtriggered_periodic
22081 Threshold-RSRP ::= INTEGER(0..97)
22084 struct Threshold_RSRP : asn::integer<>
22086 using constraint_t = asn::constraints<false,asn::span<0, 97>>;
22087 static constexpr const char* name() {return "Threshold-RSRP";}
22088 using parent_t = asn::integer<>;
22093 Threshold-RSRQ ::= INTEGER(0..34)
22096 struct Threshold_RSRQ : asn::integer<>
22098 using constraint_t = asn::constraints<false,asn::span<0, 34>>;
22099 static constexpr const char* name() {return "Threshold-RSRQ";}
22100 using parent_t = asn::integer<>;
22105 MeasurementThresholdA2 ::= CHOICE {
22106 threshold-RSRP Threshold-RSRP,
22107 threshold-RSRQ Threshold-RSRQ,
22112 struct MeasurementThresholdA2 : asn::choice<2, 0, true>
22114 static constexpr const char* name() {return "MeasurementThresholdA2";}
22115 using parent_t = asn::choice<2, 0, true>;
22116 index_type get_index() const {return index;}
22117 bool is_unknown() const {return index == 3;}
22118 void set_unknown() { set_index(3); }
22119 ~MeasurementThresholdA2() {clear();}
22120 struct threshold_RSRP_t : Threshold_RSRP
22122 static constexpr const char* name() {return "threshold_RSRP_t";}
22123 using parent_t = Threshold_RSRP;
22126 struct threshold_RSRQ_t : Threshold_RSRQ
22128 static constexpr const char* name() {return "threshold_RSRQ_t";}
22129 using parent_t = Threshold_RSRQ;
22134 switch(get_index())
22136 case 1: var.destroy<threshold_RSRP_t>(); break;
22137 case 2: var.destroy<threshold_RSRQ_t>(); break;
22142 template<typename V> bool decode(size_t idx, V& v)
22147 case 1: set_index(1); return v(var.build<threshold_RSRP_t>());
22148 case 2: set_index(2); return v(var.build<threshold_RSRQ_t>());
22153 template<typename V> bool encode(V& v) const
22155 switch(get_index())
22157 case 1: return v(var.as<threshold_RSRP_t>());
22158 case 2: return v(var.as<threshold_RSRQ_t>());
22162 template<typename V> static inline void enumerate(V& v)
22164 v.template operator()<threshold_RSRP_t>(1);
22165 v.template operator()<threshold_RSRQ_t>(2);
22168 threshold_RSRP_t& select_threshold_RSRP() { if(get_index() != 1) { clear(); set_index(1); return var.build<threshold_RSRP_t>();} return var.as<threshold_RSRP_t>();}
22169 threshold_RSRP_t const* get_threshold_RSRP() const { if(get_index() == 1) { return &var.as<threshold_RSRP_t>();} return nullptr; }
22170 threshold_RSRQ_t& select_threshold_RSRQ() { if(get_index() != 2) { clear(); set_index(2); return var.build<threshold_RSRQ_t>();} return var.as<threshold_RSRQ_t>();}
22171 threshold_RSRQ_t const* get_threshold_RSRQ() const { if(get_index() == 2) { return &var.as<threshold_RSRQ_t>();} return nullptr; }
22173 void set_index(index_type i) {index = i; base::set();}
22176 char dummy1[sizeof(threshold_RSRP_t)];
22177 char dummy2[sizeof(threshold_RSRQ_t)];
22180 asn::variant<sizeof(union_type)> var;
22181 index_type index {0};
22184 M1ThresholdEventA2-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22189 struct M1ThresholdEventA2_ExtIEs
22191 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22193 size_t get_index() const {return type;}
22194 bool is_unknown() const { return type == 1; }
22195 void clear() {type = 0;}
22196 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22197 template<typename V> bool decode(V& v)
22200 if(!v(ref_nested())) return false;
22201 { type = 1; return true;}
22205 template<typename V> bool encode(V& v) const
22207 return v(ref_nested());
22211 template<typename V> bool decode(size_t index, V& v)
22216 case 1: type = 1; return v(ref_nested());
22217 ref_nested().clear();
22222 template<typename V> bool encode(size_t index, V& v) const
22224 if(index != type) {return false;} return v(ref_nested());
22231 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22233 size_t get_index() const {return type;}
22234 bool is_unknown() const { return type == 1; }
22235 void clear() {type = 0;}
22236 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22237 template<typename V> bool decode(V& v)
22240 if(!v(ref_nested())) return false;
22241 { type = 1; return true;}
22245 template<typename V> bool encode(V& v) const
22247 return v(ref_nested());
22251 template<typename V> bool decode(size_t index, V& v)
22256 case 1: type = 1; return v(ref_nested());
22257 ref_nested().clear();
22262 template<typename V> bool encode(size_t index, V& v) const
22264 if(index != type) {return false;} return v(ref_nested());
22271 struct Extension_t : asn::typefield<true>
22273 ~Extension_t() {clear();}
22274 size_t get_index() const {return type;}
22275 bool is_unknown() const { return type == 1; }
22278 type = 0; ref_nested().clear();
22280 template<typename V> static inline void enumerate(V& v)
22285 template<typename V> bool decode(size_t index, V& v)
22290 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22295 template<typename V> bool encode(size_t index, V& v) const
22297 if(index != type) return false;
22305 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22307 size_t get_index() const {return type;}
22308 bool is_unknown() const { return type == 1; }
22309 void clear() {type = 0;}
22310 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22311 template<typename V> bool decode(V& v)
22314 if(!v(ref_nested())) return false;
22315 { type = 1; return true;}
22319 template<typename V> bool encode(V& v) const
22321 return v(ref_nested());
22325 template<typename V> bool decode(size_t index, V& v)
22330 case 1: type = 1; return v(ref_nested());
22331 ref_nested().clear();
22336 template<typename V> bool encode(size_t index, V& v) const
22338 if(index != type) {return false;} return v(ref_nested());
22348 M1ThresholdEventA2 ::= SEQUENCE {
22349 measurementThreshold MeasurementThresholdA2,
22350 iE-Extensions ProtocolExtensionContainer { {M1ThresholdEventA2-ExtIEs} } OPTIONAL,
22355 struct M1ThresholdEventA2 : asn::sequence<2, 0, true, 1>
22357 static constexpr const char* name() {return "M1ThresholdEventA2";}
22358 using parent_t = asn::sequence<2, 0, true, 1>;
22359 struct measurementThreshold_t : MeasurementThresholdA2
22361 static constexpr const char* name() {return "measurementThreshold_t";}
22362 using parent_t = MeasurementThresholdA2;
22365 measurementThreshold_t& ref_measurementThreshold() {return measurementThreshold;}
22366 measurementThreshold_t const& ref_measurementThreshold() const {return measurementThreshold;}
22367 struct iE_Extensions_t : ProtocolExtensionContainer<M1ThresholdEventA2_ExtIEs>
22369 static constexpr const char* name() {return "iE_Extensions_t";}
22370 using parent_t = ProtocolExtensionContainer<M1ThresholdEventA2_ExtIEs>;
22371 static constexpr bool optional = true;
22374 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22375 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22376 template<typename V> void decode(V& v)
22378 v(measurementThreshold);
22382 template<typename V> void encode(V& v) const
22384 v(measurementThreshold);
22390 measurementThreshold.clear();
22391 iE_Extensions.clear();
22395 measurementThreshold_t measurementThreshold;
22396 iE_Extensions_t iE_Extensions;
22400 M3period ::= ENUMERATED {ms100, ms1000, ms10000, ... }
22403 struct M3period : asn::enumerated<3, 0, true>
22405 static constexpr const char* name() {return "M3period";}
22406 using parent_t = asn::enumerated<3, 0, true>;
22416 M3Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22421 struct M3Configuration_ExtIEs
22423 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22425 size_t get_index() const {return type;}
22426 bool is_unknown() const { return type == 1; }
22427 void clear() {type = 0;}
22428 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22429 template<typename V> bool decode(V& v)
22432 if(!v(ref_nested())) return false;
22433 { type = 1; return true;}
22437 template<typename V> bool encode(V& v) const
22439 return v(ref_nested());
22443 template<typename V> bool decode(size_t index, V& v)
22448 case 1: type = 1; return v(ref_nested());
22449 ref_nested().clear();
22454 template<typename V> bool encode(size_t index, V& v) const
22456 if(index != type) {return false;} return v(ref_nested());
22463 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22465 size_t get_index() const {return type;}
22466 bool is_unknown() const { return type == 1; }
22467 void clear() {type = 0;}
22468 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22469 template<typename V> bool decode(V& v)
22472 if(!v(ref_nested())) return false;
22473 { type = 1; return true;}
22477 template<typename V> bool encode(V& v) const
22479 return v(ref_nested());
22483 template<typename V> bool decode(size_t index, V& v)
22488 case 1: type = 1; return v(ref_nested());
22489 ref_nested().clear();
22494 template<typename V> bool encode(size_t index, V& v) const
22496 if(index != type) {return false;} return v(ref_nested());
22503 struct Extension_t : asn::typefield<true>
22505 ~Extension_t() {clear();}
22506 size_t get_index() const {return type;}
22507 bool is_unknown() const { return type == 1; }
22510 type = 0; ref_nested().clear();
22512 template<typename V> static inline void enumerate(V& v)
22517 template<typename V> bool decode(size_t index, V& v)
22522 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22527 template<typename V> bool encode(size_t index, V& v) const
22529 if(index != type) return false;
22537 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22539 size_t get_index() const {return type;}
22540 bool is_unknown() const { return type == 1; }
22541 void clear() {type = 0;}
22542 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22543 template<typename V> bool decode(V& v)
22546 if(!v(ref_nested())) return false;
22547 { type = 1; return true;}
22551 template<typename V> bool encode(V& v) const
22553 return v(ref_nested());
22557 template<typename V> bool decode(size_t index, V& v)
22562 case 1: type = 1; return v(ref_nested());
22563 ref_nested().clear();
22568 template<typename V> bool encode(size_t index, V& v) const
22570 if(index != type) {return false;} return v(ref_nested());
22580 M3Configuration ::= SEQUENCE {
22582 iE-Extensions ProtocolExtensionContainer { {M3Configuration-ExtIEs} } OPTIONAL,
22587 struct M3Configuration : asn::sequence<2, 0, true, 1>
22589 static constexpr const char* name() {return "M3Configuration";}
22590 using parent_t = asn::sequence<2, 0, true, 1>;
22591 struct m3period_t : M3period
22593 static constexpr const char* name() {return "m3period_t";}
22594 using parent_t = M3period;
22597 m3period_t& ref_m3period() {return m3period;}
22598 m3period_t const& ref_m3period() const {return m3period;}
22599 struct iE_Extensions_t : ProtocolExtensionContainer<M3Configuration_ExtIEs>
22601 static constexpr const char* name() {return "iE_Extensions_t";}
22602 using parent_t = ProtocolExtensionContainer<M3Configuration_ExtIEs>;
22603 static constexpr bool optional = true;
22606 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22607 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22608 template<typename V> void decode(V& v)
22614 template<typename V> void encode(V& v) const
22623 iE_Extensions.clear();
22627 m3period_t m3period;
22628 iE_Extensions_t iE_Extensions;
22632 M4period ::= ENUMERATED {ms1024, ms2048, ms5120, ms10240, min1, ... }
22635 struct M4period : asn::enumerated<5, 0, true>
22637 static constexpr const char* name() {return "M4period";}
22638 using parent_t = asn::enumerated<5, 0, true>;
22650 M4Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22655 struct M4Configuration_ExtIEs
22657 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22659 size_t get_index() const {return type;}
22660 bool is_unknown() const { return type == 1; }
22661 void clear() {type = 0;}
22662 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22663 template<typename V> bool decode(V& v)
22666 if(!v(ref_nested())) return false;
22667 { type = 1; return true;}
22671 template<typename V> bool encode(V& v) const
22673 return v(ref_nested());
22677 template<typename V> bool decode(size_t index, V& v)
22682 case 1: type = 1; return v(ref_nested());
22683 ref_nested().clear();
22688 template<typename V> bool encode(size_t index, V& v) const
22690 if(index != type) {return false;} return v(ref_nested());
22697 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22699 size_t get_index() const {return type;}
22700 bool is_unknown() const { return type == 1; }
22701 void clear() {type = 0;}
22702 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22703 template<typename V> bool decode(V& v)
22706 if(!v(ref_nested())) return false;
22707 { type = 1; return true;}
22711 template<typename V> bool encode(V& v) const
22713 return v(ref_nested());
22717 template<typename V> bool decode(size_t index, V& v)
22722 case 1: type = 1; return v(ref_nested());
22723 ref_nested().clear();
22728 template<typename V> bool encode(size_t index, V& v) const
22730 if(index != type) {return false;} return v(ref_nested());
22737 struct Extension_t : asn::typefield<true>
22739 ~Extension_t() {clear();}
22740 size_t get_index() const {return type;}
22741 bool is_unknown() const { return type == 1; }
22744 type = 0; ref_nested().clear();
22746 template<typename V> static inline void enumerate(V& v)
22751 template<typename V> bool decode(size_t index, V& v)
22756 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
22761 template<typename V> bool encode(size_t index, V& v) const
22763 if(index != type) return false;
22771 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
22773 size_t get_index() const {return type;}
22774 bool is_unknown() const { return type == 1; }
22775 void clear() {type = 0;}
22776 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
22777 template<typename V> bool decode(V& v)
22780 if(!v(ref_nested())) return false;
22781 { type = 1; return true;}
22785 template<typename V> bool encode(V& v) const
22787 return v(ref_nested());
22791 template<typename V> bool decode(size_t index, V& v)
22796 case 1: type = 1; return v(ref_nested());
22797 ref_nested().clear();
22802 template<typename V> bool encode(size_t index, V& v) const
22804 if(index != type) {return false;} return v(ref_nested());
22814 M4Configuration ::= SEQUENCE {
22816 m4-links-to-log Links-to-log,
22817 iE-Extensions ProtocolExtensionContainer { {M4Configuration-ExtIEs} } OPTIONAL,
22822 struct M4Configuration : asn::sequence<3, 0, true, 1>
22824 static constexpr const char* name() {return "M4Configuration";}
22825 using parent_t = asn::sequence<3, 0, true, 1>;
22826 struct m4period_t : M4period
22828 static constexpr const char* name() {return "m4period_t";}
22829 using parent_t = M4period;
22832 m4period_t& ref_m4period() {return m4period;}
22833 m4period_t const& ref_m4period() const {return m4period;}
22834 struct m4_links_to_log_t : Links_to_log
22836 static constexpr const char* name() {return "m4_links_to_log_t";}
22837 using parent_t = Links_to_log;
22840 m4_links_to_log_t& ref_m4_links_to_log() {return m4_links_to_log;}
22841 m4_links_to_log_t const& ref_m4_links_to_log() const {return m4_links_to_log;}
22842 struct iE_Extensions_t : ProtocolExtensionContainer<M4Configuration_ExtIEs>
22844 static constexpr const char* name() {return "iE_Extensions_t";}
22845 using parent_t = ProtocolExtensionContainer<M4Configuration_ExtIEs>;
22846 static constexpr bool optional = true;
22849 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
22850 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
22851 template<typename V> void decode(V& v)
22854 v(m4_links_to_log);
22858 template<typename V> void encode(V& v) const
22861 v(m4_links_to_log);
22868 m4_links_to_log.clear();
22869 iE_Extensions.clear();
22873 m4period_t m4period;
22874 m4_links_to_log_t m4_links_to_log;
22875 iE_Extensions_t iE_Extensions;
22879 M5period ::= ENUMERATED {ms1024, ms2048, ms5120, ms10240, min1, ... }
22882 struct M5period : asn::enumerated<5, 0, true>
22884 static constexpr const char* name() {return "M5period";}
22885 using parent_t = asn::enumerated<5, 0, true>;
22897 M5Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
22902 struct M5Configuration_ExtIEs
22904 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
22906 size_t get_index() const {return type;}
22907 bool is_unknown() const { return type == 1; }
22908 void clear() {type = 0;}
22909 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
22910 template<typename V> bool decode(V& v)
22913 if(!v(ref_nested())) return false;
22914 { type = 1; return true;}
22918 template<typename V> bool encode(V& v) const
22920 return v(ref_nested());
22924 template<typename V> bool decode(size_t index, V& v)
22929 case 1: type = 1; return v(ref_nested());
22930 ref_nested().clear();
22935 template<typename V> bool encode(size_t index, V& v) const
22937 if(index != type) {return false;} return v(ref_nested());
22944 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
22946 size_t get_index() const {return type;}
22947 bool is_unknown() const { return type == 1; }
22948 void clear() {type = 0;}
22949 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
22950 template<typename V> bool decode(V& v)
22953 if(!v(ref_nested())) return false;
22954 { type = 1; return true;}
22958 template<typename V> bool encode(V& v) const
22960 return v(ref_nested());
22964 template<typename V> bool decode(size_t index, V& v)
22969 case 1: type = 1; return v(ref_nested());
22970 ref_nested().clear();
22975 template<typename V> bool encode(size_t index, V& v) const
22977 if(index != type) {return false;} return v(ref_nested());
22984 struct Extension_t : asn::typefield<true>
22986 ~Extension_t() {clear();}
22987 size_t get_index() const {return type;}
22988 bool is_unknown() const { return type == 1; }
22991 type = 0; ref_nested().clear();
22993 template<typename V> static inline void enumerate(V& v)
22998 template<typename V> bool decode(size_t index, V& v)
23003 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23008 template<typename V> bool encode(size_t index, V& v) const
23010 if(index != type) return false;
23018 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23020 size_t get_index() const {return type;}
23021 bool is_unknown() const { return type == 1; }
23022 void clear() {type = 0;}
23023 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23024 template<typename V> bool decode(V& v)
23027 if(!v(ref_nested())) return false;
23028 { type = 1; return true;}
23032 template<typename V> bool encode(V& v) const
23034 return v(ref_nested());
23038 template<typename V> bool decode(size_t index, V& v)
23043 case 1: type = 1; return v(ref_nested());
23044 ref_nested().clear();
23049 template<typename V> bool encode(size_t index, V& v) const
23051 if(index != type) {return false;} return v(ref_nested());
23061 M5Configuration ::= SEQUENCE {
23063 m5-links-to-log Links-to-log,
23064 iE-Extensions ProtocolExtensionContainer { {M5Configuration-ExtIEs} } OPTIONAL,
23069 struct M5Configuration : asn::sequence<3, 0, true, 1>
23071 static constexpr const char* name() {return "M5Configuration";}
23072 using parent_t = asn::sequence<3, 0, true, 1>;
23073 struct m5period_t : M5period
23075 static constexpr const char* name() {return "m5period_t";}
23076 using parent_t = M5period;
23079 m5period_t& ref_m5period() {return m5period;}
23080 m5period_t const& ref_m5period() const {return m5period;}
23081 struct m5_links_to_log_t : Links_to_log
23083 static constexpr const char* name() {return "m5_links_to_log_t";}
23084 using parent_t = Links_to_log;
23087 m5_links_to_log_t& ref_m5_links_to_log() {return m5_links_to_log;}
23088 m5_links_to_log_t const& ref_m5_links_to_log() const {return m5_links_to_log;}
23089 struct iE_Extensions_t : ProtocolExtensionContainer<M5Configuration_ExtIEs>
23091 static constexpr const char* name() {return "iE_Extensions_t";}
23092 using parent_t = ProtocolExtensionContainer<M5Configuration_ExtIEs>;
23093 static constexpr bool optional = true;
23096 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
23097 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
23098 template<typename V> void decode(V& v)
23101 v(m5_links_to_log);
23105 template<typename V> void encode(V& v) const
23108 v(m5_links_to_log);
23115 m5_links_to_log.clear();
23116 iE_Extensions.clear();
23120 m5period_t m5period;
23121 m5_links_to_log_t m5_links_to_log;
23122 iE_Extensions_t iE_Extensions;
23126 M6report-interval ::= ENUMERATED { ms1024, ms2048, ms5120, ms10240, ... }
23129 struct M6report_interval : asn::enumerated<4, 0, true>
23131 static constexpr const char* name() {return "M6report-interval";}
23132 using parent_t = asn::enumerated<4, 0, true>;
23143 M6delay-threshold ::= ENUMERATED { ms30, ms40, ms50, ms60, ms70, ms80, ms90, ms100, ms150, ms300, ms500, ms750, ... }
23146 struct M6delay_threshold : asn::enumerated<12, 0, true>
23148 static constexpr const char* name() {return "M6delay-threshold";}
23149 using parent_t = asn::enumerated<12, 0, true>;
23168 M6Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
23173 struct M6Configuration_ExtIEs
23175 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
23177 size_t get_index() const {return type;}
23178 bool is_unknown() const { return type == 1; }
23179 void clear() {type = 0;}
23180 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
23181 template<typename V> bool decode(V& v)
23184 if(!v(ref_nested())) return false;
23185 { type = 1; return true;}
23189 template<typename V> bool encode(V& v) const
23191 return v(ref_nested());
23195 template<typename V> bool decode(size_t index, V& v)
23200 case 1: type = 1; return v(ref_nested());
23201 ref_nested().clear();
23206 template<typename V> bool encode(size_t index, V& v) const
23208 if(index != type) {return false;} return v(ref_nested());
23215 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
23217 size_t get_index() const {return type;}
23218 bool is_unknown() const { return type == 1; }
23219 void clear() {type = 0;}
23220 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
23221 template<typename V> bool decode(V& v)
23224 if(!v(ref_nested())) return false;
23225 { type = 1; return true;}
23229 template<typename V> bool encode(V& v) const
23231 return v(ref_nested());
23235 template<typename V> bool decode(size_t index, V& v)
23240 case 1: type = 1; return v(ref_nested());
23241 ref_nested().clear();
23246 template<typename V> bool encode(size_t index, V& v) const
23248 if(index != type) {return false;} return v(ref_nested());
23255 struct Extension_t : asn::typefield<true>
23257 ~Extension_t() {clear();}
23258 size_t get_index() const {return type;}
23259 bool is_unknown() const { return type == 1; }
23262 type = 0; ref_nested().clear();
23264 template<typename V> static inline void enumerate(V& v)
23269 template<typename V> bool decode(size_t index, V& v)
23274 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23279 template<typename V> bool encode(size_t index, V& v) const
23281 if(index != type) return false;
23289 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23291 size_t get_index() const {return type;}
23292 bool is_unknown() const { return type == 1; }
23293 void clear() {type = 0;}
23294 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23295 template<typename V> bool decode(V& v)
23298 if(!v(ref_nested())) return false;
23299 { type = 1; return true;}
23303 template<typename V> bool encode(V& v) const
23305 return v(ref_nested());
23309 template<typename V> bool decode(size_t index, V& v)
23314 case 1: type = 1; return v(ref_nested());
23315 ref_nested().clear();
23320 template<typename V> bool encode(size_t index, V& v) const
23322 if(index != type) {return false;} return v(ref_nested());
23332 M6Configuration ::= SEQUENCE {
23333 m6report-interval M6report-interval,
23334 m6delay-threshold M6delay-threshold OPTIONAL,
23335 -- This IE shall be present if the M6 Links to log IE is set to “uplink” or to “both-uplink-and-downlink” --
23336 m6-links-to-log Links-to-log,
23337 iE-Extensions ProtocolExtensionContainer { {M6Configuration-ExtIEs} } OPTIONAL,
23342 struct M6Configuration : asn::sequence<4, 0, true, 2>
23344 static constexpr const char* name() {return "M6Configuration";}
23345 using parent_t = asn::sequence<4, 0, true, 2>;
23346 struct m6report_interval_t : M6report_interval
23348 static constexpr const char* name() {return "m6report_interval_t";}
23349 using parent_t = M6report_interval;
23352 m6report_interval_t& ref_m6report_interval() {return m6report_interval;}
23353 m6report_interval_t const& ref_m6report_interval() const {return m6report_interval;}
23354 struct m6delay_threshold_t : M6delay_threshold
23356 static constexpr const char* name() {return "m6delay_threshold_t";}
23357 using parent_t = M6delay_threshold;
23358 static constexpr bool optional = true;
23361 m6delay_threshold_t& set_m6delay_threshold() { m6delay_threshold.setpresent(true); return m6delay_threshold;}
23362 m6delay_threshold_t const* get_m6delay_threshold() const {return m6delay_threshold.is_valid() ? &m6delay_threshold : nullptr;}
23363 struct m6_links_to_log_t : Links_to_log
23365 static constexpr const char* name() {return "m6_links_to_log_t";}
23366 using parent_t = Links_to_log;
23369 m6_links_to_log_t& ref_m6_links_to_log() {return m6_links_to_log;}
23370 m6_links_to_log_t const& ref_m6_links_to_log() const {return m6_links_to_log;}
23371 struct iE_Extensions_t : ProtocolExtensionContainer<M6Configuration_ExtIEs>
23373 static constexpr const char* name() {return "iE_Extensions_t";}
23374 using parent_t = ProtocolExtensionContainer<M6Configuration_ExtIEs>;
23375 static constexpr bool optional = true;
23378 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
23379 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
23380 template<typename V> void decode(V& v)
23382 v(m6report_interval);
23383 v(m6delay_threshold);
23384 v(m6_links_to_log);
23388 template<typename V> void encode(V& v) const
23390 v(m6report_interval);
23391 v(m6delay_threshold);
23392 v(m6_links_to_log);
23398 m6report_interval.clear();
23399 m6delay_threshold.clear();
23400 m6_links_to_log.clear();
23401 iE_Extensions.clear();
23405 m6report_interval_t m6report_interval;
23406 m6delay_threshold_t m6delay_threshold;
23407 m6_links_to_log_t m6_links_to_log;
23408 iE_Extensions_t iE_Extensions;
23412 M7period ::= INTEGER(1..60, ...)
23415 struct M7period : asn::integer<>
23417 using constraint_t = asn::constraints<true,asn::span<1, 60>>;
23418 static constexpr const char* name() {return "M7period";}
23419 using parent_t = asn::integer<>;
23424 M7Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
23429 struct M7Configuration_ExtIEs
23431 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
23433 size_t get_index() const {return type;}
23434 bool is_unknown() const { return type == 1; }
23435 void clear() {type = 0;}
23436 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
23437 template<typename V> bool decode(V& v)
23440 if(!v(ref_nested())) return false;
23441 { type = 1; return true;}
23445 template<typename V> bool encode(V& v) const
23447 return v(ref_nested());
23451 template<typename V> bool decode(size_t index, V& v)
23456 case 1: type = 1; return v(ref_nested());
23457 ref_nested().clear();
23462 template<typename V> bool encode(size_t index, V& v) const
23464 if(index != type) {return false;} return v(ref_nested());
23471 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
23473 size_t get_index() const {return type;}
23474 bool is_unknown() const { return type == 1; }
23475 void clear() {type = 0;}
23476 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
23477 template<typename V> bool decode(V& v)
23480 if(!v(ref_nested())) return false;
23481 { type = 1; return true;}
23485 template<typename V> bool encode(V& v) const
23487 return v(ref_nested());
23491 template<typename V> bool decode(size_t index, V& v)
23496 case 1: type = 1; return v(ref_nested());
23497 ref_nested().clear();
23502 template<typename V> bool encode(size_t index, V& v) const
23504 if(index != type) {return false;} return v(ref_nested());
23511 struct Extension_t : asn::typefield<true>
23513 ~Extension_t() {clear();}
23514 size_t get_index() const {return type;}
23515 bool is_unknown() const { return type == 1; }
23518 type = 0; ref_nested().clear();
23520 template<typename V> static inline void enumerate(V& v)
23525 template<typename V> bool decode(size_t index, V& v)
23530 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23535 template<typename V> bool encode(size_t index, V& v) const
23537 if(index != type) return false;
23545 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23547 size_t get_index() const {return type;}
23548 bool is_unknown() const { return type == 1; }
23549 void clear() {type = 0;}
23550 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23551 template<typename V> bool decode(V& v)
23554 if(!v(ref_nested())) return false;
23555 { type = 1; return true;}
23559 template<typename V> bool encode(V& v) const
23561 return v(ref_nested());
23565 template<typename V> bool decode(size_t index, V& v)
23570 case 1: type = 1; return v(ref_nested());
23571 ref_nested().clear();
23576 template<typename V> bool encode(size_t index, V& v) const
23578 if(index != type) {return false;} return v(ref_nested());
23588 M7Configuration ::= SEQUENCE {
23590 m7-links-to-log Links-to-log,
23591 iE-Extensions ProtocolExtensionContainer { {M7Configuration-ExtIEs} } OPTIONAL,
23596 struct M7Configuration : asn::sequence<3, 0, true, 1>
23598 static constexpr const char* name() {return "M7Configuration";}
23599 using parent_t = asn::sequence<3, 0, true, 1>;
23600 struct m7period_t : M7period
23602 static constexpr const char* name() {return "m7period_t";}
23603 using parent_t = M7period;
23606 m7period_t& ref_m7period() {return m7period;}
23607 m7period_t const& ref_m7period() const {return m7period;}
23608 struct m7_links_to_log_t : Links_to_log
23610 static constexpr const char* name() {return "m7_links_to_log_t";}
23611 using parent_t = Links_to_log;
23614 m7_links_to_log_t& ref_m7_links_to_log() {return m7_links_to_log;}
23615 m7_links_to_log_t const& ref_m7_links_to_log() const {return m7_links_to_log;}
23616 struct iE_Extensions_t : ProtocolExtensionContainer<M7Configuration_ExtIEs>
23618 static constexpr const char* name() {return "iE_Extensions_t";}
23619 using parent_t = ProtocolExtensionContainer<M7Configuration_ExtIEs>;
23620 static constexpr bool optional = true;
23623 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
23624 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
23625 template<typename V> void decode(V& v)
23628 v(m7_links_to_log);
23632 template<typename V> void encode(V& v) const
23635 v(m7_links_to_log);
23642 m7_links_to_log.clear();
23643 iE_Extensions.clear();
23647 m7period_t m7period;
23648 m7_links_to_log_t m7_links_to_log;
23649 iE_Extensions_t iE_Extensions;
23653 MBMS-Service-Area-Identity ::= OCTET STRING (SIZE (2))
23656 struct MBMS_Service_Area_Identity : asn::ostring<>
23658 using constraint_t = asn::constraints<false,asn::one<2>>;
23659 static constexpr const char* name() {return "MBMS-Service-Area-Identity";}
23660 using parent_t = asn::ostring<>;
23665 MBMS-Service-Area-Identity-List ::= SEQUENCE (SIZE(1.. maxnoofMBMSServiceAreaIdentities)) OF MBMS-Service-Area-Identity
23668 struct MBMS_Service_Area_Identity_List_elm : MBMS_Service_Area_Identity
23670 static constexpr const char* name() {return "MBMS_Service_Area_Identity_List_elm";}
23671 using parent_t = MBMS_Service_Area_Identity;
23674 struct MBMS_Service_Area_Identity_List : asn::sequenceof<MBMS_Service_Area_Identity_List_elm>
23676 static constexpr const char* name() {return "MBMS-Service-Area-Identity-List";}
23677 using parent_t = asn::sequenceof<MBMS_Service_Area_Identity_List_elm>;
23678 using constraint_t = asn::constraints<false,asn::span<1, maxnoofMBMSServiceAreaIdentities >>;
23682 RadioframeAllocationPeriod ::= ENUMERATED{
23693 struct RadioframeAllocationPeriod : asn::enumerated<6, 0, true>
23695 static constexpr const char* name() {return "RadioframeAllocationPeriod";}
23696 using parent_t = asn::enumerated<6, 0, true>;
23709 RadioframeAllocationOffset ::= INTEGER (0..7, ...)
23712 struct RadioframeAllocationOffset : asn::integer<>
23714 using constraint_t = asn::constraints<true,asn::span<0, 7>>;
23715 static constexpr const char* name() {return "RadioframeAllocationOffset";}
23716 using parent_t = asn::integer<>;
23721 Oneframe ::= BIT STRING (SIZE (6))
23724 struct Oneframe : asn::bstring<>
23726 using constraint_t = asn::constraints<false,asn::one<6>>;
23727 static constexpr const char* name() {return "Oneframe";}
23728 using parent_t = asn::bstring<>;
23733 SubframeAllocation ::= CHOICE {
23735 fourframes Fourframes,
23740 struct SubframeAllocation : asn::choice<2, 0, true>
23742 static constexpr const char* name() {return "SubframeAllocation";}
23743 using parent_t = asn::choice<2, 0, true>;
23744 index_type get_index() const {return index;}
23745 bool is_unknown() const {return index == 3;}
23746 void set_unknown() { set_index(3); }
23747 ~SubframeAllocation() {clear();}
23748 struct oneframe_t : Oneframe
23750 static constexpr const char* name() {return "oneframe_t";}
23751 using parent_t = Oneframe;
23754 struct fourframes_t : Fourframes
23756 static constexpr const char* name() {return "fourframes_t";}
23757 using parent_t = Fourframes;
23762 switch(get_index())
23764 case 1: var.destroy<oneframe_t>(); break;
23765 case 2: var.destroy<fourframes_t>(); break;
23770 template<typename V> bool decode(size_t idx, V& v)
23775 case 1: set_index(1); return v(var.build<oneframe_t>());
23776 case 2: set_index(2); return v(var.build<fourframes_t>());
23781 template<typename V> bool encode(V& v) const
23783 switch(get_index())
23785 case 1: return v(var.as<oneframe_t>());
23786 case 2: return v(var.as<fourframes_t>());
23790 template<typename V> static inline void enumerate(V& v)
23792 v.template operator()<oneframe_t>(1);
23793 v.template operator()<fourframes_t>(2);
23796 oneframe_t& select_oneframe() { if(get_index() != 1) { clear(); set_index(1); return var.build<oneframe_t>();} return var.as<oneframe_t>();}
23797 oneframe_t const* get_oneframe() const { if(get_index() == 1) { return &var.as<oneframe_t>();} return nullptr; }
23798 fourframes_t& select_fourframes() { if(get_index() != 2) { clear(); set_index(2); return var.build<fourframes_t>();} return var.as<fourframes_t>();}
23799 fourframes_t const* get_fourframes() const { if(get_index() == 2) { return &var.as<fourframes_t>();} return nullptr; }
23801 void set_index(index_type i) {index = i; base::set();}
23804 char dummy1[sizeof(oneframe_t)];
23805 char dummy2[sizeof(fourframes_t)];
23808 asn::variant<sizeof(union_type)> var;
23809 index_type index {0};
23812 MBSFN-Subframe-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
23817 struct MBSFN_Subframe_Info_ExtIEs
23819 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
23821 size_t get_index() const {return type;}
23822 bool is_unknown() const { return type == 1; }
23823 void clear() {type = 0;}
23824 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
23825 template<typename V> bool decode(V& v)
23828 if(!v(ref_nested())) return false;
23829 { type = 1; return true;}
23833 template<typename V> bool encode(V& v) const
23835 return v(ref_nested());
23839 template<typename V> bool decode(size_t index, V& v)
23844 case 1: type = 1; return v(ref_nested());
23845 ref_nested().clear();
23850 template<typename V> bool encode(size_t index, V& v) const
23852 if(index != type) {return false;} return v(ref_nested());
23859 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
23861 size_t get_index() const {return type;}
23862 bool is_unknown() const { return type == 1; }
23863 void clear() {type = 0;}
23864 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
23865 template<typename V> bool decode(V& v)
23868 if(!v(ref_nested())) return false;
23869 { type = 1; return true;}
23873 template<typename V> bool encode(V& v) const
23875 return v(ref_nested());
23879 template<typename V> bool decode(size_t index, V& v)
23884 case 1: type = 1; return v(ref_nested());
23885 ref_nested().clear();
23890 template<typename V> bool encode(size_t index, V& v) const
23892 if(index != type) {return false;} return v(ref_nested());
23899 struct Extension_t : asn::typefield<true>
23901 ~Extension_t() {clear();}
23902 size_t get_index() const {return type;}
23903 bool is_unknown() const { return type == 1; }
23906 type = 0; ref_nested().clear();
23908 template<typename V> static inline void enumerate(V& v)
23913 template<typename V> bool decode(size_t index, V& v)
23918 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
23923 template<typename V> bool encode(size_t index, V& v) const
23925 if(index != type) return false;
23933 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
23935 size_t get_index() const {return type;}
23936 bool is_unknown() const { return type == 1; }
23937 void clear() {type = 0;}
23938 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
23939 template<typename V> bool decode(V& v)
23942 if(!v(ref_nested())) return false;
23943 { type = 1; return true;}
23947 template<typename V> bool encode(V& v) const
23949 return v(ref_nested());
23953 template<typename V> bool decode(size_t index, V& v)
23958 case 1: type = 1; return v(ref_nested());
23959 ref_nested().clear();
23964 template<typename V> bool encode(size_t index, V& v) const
23966 if(index != type) {return false;} return v(ref_nested());
23976 MBSFN-Subframe-Info ::= SEQUENCE {
23977 radioframeAllocationPeriod RadioframeAllocationPeriod,
23978 radioframeAllocationOffset RadioframeAllocationOffset,
23979 subframeAllocation SubframeAllocation,
23980 iE-Extensions ProtocolExtensionContainer { {MBSFN-Subframe-Info-ExtIEs} } OPTIONAL,
23985 struct MBSFN_Subframe_Info : asn::sequence<4, 0, true, 1>
23987 static constexpr const char* name() {return "MBSFN-Subframe-Info";}
23988 using parent_t = asn::sequence<4, 0, true, 1>;
23989 struct radioframeAllocationPeriod_t : RadioframeAllocationPeriod
23991 static constexpr const char* name() {return "radioframeAllocationPeriod_t";}
23992 using parent_t = RadioframeAllocationPeriod;
23995 radioframeAllocationPeriod_t& ref_radioframeAllocationPeriod() {return radioframeAllocationPeriod;}
23996 radioframeAllocationPeriod_t const& ref_radioframeAllocationPeriod() const {return radioframeAllocationPeriod;}
23997 struct radioframeAllocationOffset_t : RadioframeAllocationOffset
23999 static constexpr const char* name() {return "radioframeAllocationOffset_t";}
24000 using parent_t = RadioframeAllocationOffset;
24003 radioframeAllocationOffset_t& ref_radioframeAllocationOffset() {return radioframeAllocationOffset;}
24004 radioframeAllocationOffset_t const& ref_radioframeAllocationOffset() const {return radioframeAllocationOffset;}
24005 struct subframeAllocation_t : SubframeAllocation
24007 static constexpr const char* name() {return "subframeAllocation_t";}
24008 using parent_t = SubframeAllocation;
24011 subframeAllocation_t& ref_subframeAllocation() {return subframeAllocation;}
24012 subframeAllocation_t const& ref_subframeAllocation() const {return subframeAllocation;}
24013 struct iE_Extensions_t : ProtocolExtensionContainer<MBSFN_Subframe_Info_ExtIEs>
24015 static constexpr const char* name() {return "iE_Extensions_t";}
24016 using parent_t = ProtocolExtensionContainer<MBSFN_Subframe_Info_ExtIEs>;
24017 static constexpr bool optional = true;
24020 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24021 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24022 template<typename V> void decode(V& v)
24024 v(radioframeAllocationPeriod);
24025 v(radioframeAllocationOffset);
24026 v(subframeAllocation);
24030 template<typename V> void encode(V& v) const
24032 v(radioframeAllocationPeriod);
24033 v(radioframeAllocationOffset);
24034 v(subframeAllocation);
24040 radioframeAllocationPeriod.clear();
24041 radioframeAllocationOffset.clear();
24042 subframeAllocation.clear();
24043 iE_Extensions.clear();
24047 radioframeAllocationPeriod_t radioframeAllocationPeriod;
24048 radioframeAllocationOffset_t radioframeAllocationOffset;
24049 subframeAllocation_t subframeAllocation;
24050 iE_Extensions_t iE_Extensions;
24054 MBSFN-Subframe-Infolist::= SEQUENCE (SIZE(1.. maxnoofMBSFN)) OF MBSFN-Subframe-Info
24057 struct MBSFN_Subframe_Infolist_elm : MBSFN_Subframe_Info
24059 static constexpr const char* name() {return "MBSFN_Subframe_Infolist_elm";}
24060 using parent_t = MBSFN_Subframe_Info;
24063 struct MBSFN_Subframe_Infolist : asn::sequenceof<MBSFN_Subframe_Infolist_elm>
24065 static constexpr const char* name() {return "MBSFN-Subframe-Infolist";}
24066 using parent_t = asn::sequenceof<MBSFN_Subframe_Infolist_elm>;
24067 using constraint_t = asn::constraints<false,asn::span<1, maxnoofMBSFN >>;
24071 MDT-Activation ::= ENUMERATED {
24072 immediate-MDT-only,
24073 immediate-MDT-and-Trace,
24078 struct MDT_Activation : asn::enumerated<2, 0, true>
24080 static constexpr const char* name() {return "MDT-Activation";}
24081 using parent_t = asn::enumerated<2, 0, true>;
24084 ,immediate_MDT_and_Trace
24090 MeasurementsToActivate::= BIT STRING (SIZE (8))
24093 struct MeasurementsToActivate : asn::bstring<>
24095 using constraint_t = asn::constraints<false,asn::one<8>>;
24096 static constexpr const char* name() {return "MeasurementsToActivate";}
24097 using parent_t = asn::bstring<>;
24102 MDT-Location-Info ::= BIT STRING (SIZE (8))
24105 struct MDT_Location_Info : asn::bstring<>
24107 using constraint_t = asn::constraints<false,asn::one<8>>;
24108 static constexpr const char* name() {return "MDT-Location-Info";}
24109 using parent_t = asn::bstring<>;
24114 MDTPLMNList ::= SEQUENCE (SIZE(1..maxnoofMDTPLMNs)) OF PLMN-Identity
24117 struct MDTPLMNList_elm : PLMN_Identity
24119 static constexpr const char* name() {return "MDTPLMNList_elm";}
24120 using parent_t = PLMN_Identity;
24123 struct MDTPLMNList : asn::sequenceof<MDTPLMNList_elm>
24125 static constexpr const char* name() {return "MDTPLMNList";}
24126 using parent_t = asn::sequenceof<MDTPLMNList_elm>;
24127 using constraint_t = asn::constraints<false,asn::span<1, maxnoofMDTPLMNs >>;
24131 WLANMeasConfig::= ENUMERATED {setup,...}
24134 struct WLANMeasConfig : asn::enumerated<1, 0, true>
24136 static constexpr const char* name() {return "WLANMeasConfig";}
24137 using parent_t = asn::enumerated<1, 0, true>;
24145 WLANName ::= OCTET STRING (SIZE (1..32))
24148 struct WLANName : asn::ostring<>
24150 using constraint_t = asn::constraints<false,asn::span<1, 32>>;
24151 static constexpr const char* name() {return "WLANName";}
24152 using parent_t = asn::ostring<>;
24157 WLANMeasConfigNameList ::= SEQUENCE (SIZE(1..maxnoofWLANName)) OF WLANName
24160 struct WLANMeasConfigNameList_elm : WLANName
24162 static constexpr const char* name() {return "WLANMeasConfigNameList_elm";}
24163 using parent_t = WLANName;
24166 struct WLANMeasConfigNameList : asn::sequenceof<WLANMeasConfigNameList_elm>
24168 static constexpr const char* name() {return "WLANMeasConfigNameList";}
24169 using parent_t = asn::sequenceof<WLANMeasConfigNameList_elm>;
24170 using constraint_t = asn::constraints<false,asn::span<1, maxnoofWLANName >>;
24174 WLANMeasurementConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24179 struct WLANMeasurementConfiguration_ExtIEs
24181 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24183 size_t get_index() const {return type;}
24184 bool is_unknown() const { return type == 1; }
24185 void clear() {type = 0;}
24186 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24187 template<typename V> bool decode(V& v)
24190 if(!v(ref_nested())) return false;
24191 { type = 1; return true;}
24195 template<typename V> bool encode(V& v) const
24197 return v(ref_nested());
24201 template<typename V> bool decode(size_t index, V& v)
24206 case 1: type = 1; return v(ref_nested());
24207 ref_nested().clear();
24212 template<typename V> bool encode(size_t index, V& v) const
24214 if(index != type) {return false;} return v(ref_nested());
24221 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
24223 size_t get_index() const {return type;}
24224 bool is_unknown() const { return type == 1; }
24225 void clear() {type = 0;}
24226 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
24227 template<typename V> bool decode(V& v)
24230 if(!v(ref_nested())) return false;
24231 { type = 1; return true;}
24235 template<typename V> bool encode(V& v) const
24237 return v(ref_nested());
24241 template<typename V> bool decode(size_t index, V& v)
24246 case 1: type = 1; return v(ref_nested());
24247 ref_nested().clear();
24252 template<typename V> bool encode(size_t index, V& v) const
24254 if(index != type) {return false;} return v(ref_nested());
24261 struct Extension_t : asn::typefield<true>
24263 ~Extension_t() {clear();}
24264 size_t get_index() const {return type;}
24265 bool is_unknown() const { return type == 1; }
24268 type = 0; ref_nested().clear();
24270 template<typename V> static inline void enumerate(V& v)
24275 template<typename V> bool decode(size_t index, V& v)
24280 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
24285 template<typename V> bool encode(size_t index, V& v) const
24287 if(index != type) return false;
24295 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
24297 size_t get_index() const {return type;}
24298 bool is_unknown() const { return type == 1; }
24299 void clear() {type = 0;}
24300 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
24301 template<typename V> bool decode(V& v)
24304 if(!v(ref_nested())) return false;
24305 { type = 1; return true;}
24309 template<typename V> bool encode(V& v) const
24311 return v(ref_nested());
24315 template<typename V> bool decode(size_t index, V& v)
24320 case 1: type = 1; return v(ref_nested());
24321 ref_nested().clear();
24326 template<typename V> bool encode(size_t index, V& v) const
24328 if(index != type) {return false;} return v(ref_nested());
24338 WLANMeasurementConfiguration ::= SEQUENCE {
24339 wlanMeasConfig WLANMeasConfig,
24340 wlanMeasConfigNameList WLANMeasConfigNameList OPTIONAL,
24341 wlan-rssi ENUMERATED {true, ...} OPTIONAL,
24342 wlan-rtt ENUMERATED {true, ...} OPTIONAL,
24343 iE-Extensions ProtocolExtensionContainer { {WLANMeasurementConfiguration-ExtIEs} } OPTIONAL,
24348 struct WLANMeasurementConfiguration : asn::sequence<5, 0, true, 4>
24350 static constexpr const char* name() {return "WLANMeasurementConfiguration";}
24351 using parent_t = asn::sequence<5, 0, true, 4>;
24352 struct wlanMeasConfig_t : WLANMeasConfig
24354 static constexpr const char* name() {return "wlanMeasConfig_t";}
24355 using parent_t = WLANMeasConfig;
24358 wlanMeasConfig_t& ref_wlanMeasConfig() {return wlanMeasConfig;}
24359 wlanMeasConfig_t const& ref_wlanMeasConfig() const {return wlanMeasConfig;}
24360 struct wlanMeasConfigNameList_t : WLANMeasConfigNameList
24362 static constexpr const char* name() {return "wlanMeasConfigNameList_t";}
24363 using parent_t = WLANMeasConfigNameList;
24364 static constexpr bool optional = true;
24367 wlanMeasConfigNameList_t& set_wlanMeasConfigNameList() { wlanMeasConfigNameList.setpresent(true); return wlanMeasConfigNameList;}
24368 wlanMeasConfigNameList_t const* get_wlanMeasConfigNameList() const {return wlanMeasConfigNameList.is_valid() ? &wlanMeasConfigNameList : nullptr;}
24369 struct wlan_rssi_t : asn::enumerated<1, 0, true>
24371 static constexpr const char* name() {return "wlan_rssi_t";}
24372 using parent_t = asn::enumerated<1, 0, true>;
24373 static constexpr bool optional = true;
24380 wlan_rssi_t& set_wlan_rssi() { wlan_rssi.setpresent(true); return wlan_rssi;}
24381 wlan_rssi_t const* get_wlan_rssi() const {return wlan_rssi.is_valid() ? &wlan_rssi : nullptr;}
24382 struct wlan_rtt_t : asn::enumerated<1, 0, true>
24384 static constexpr const char* name() {return "wlan_rtt_t";}
24385 using parent_t = asn::enumerated<1, 0, true>;
24386 static constexpr bool optional = true;
24393 wlan_rtt_t& set_wlan_rtt() { wlan_rtt.setpresent(true); return wlan_rtt;}
24394 wlan_rtt_t const* get_wlan_rtt() const {return wlan_rtt.is_valid() ? &wlan_rtt : nullptr;}
24395 struct iE_Extensions_t : ProtocolExtensionContainer<WLANMeasurementConfiguration_ExtIEs>
24397 static constexpr const char* name() {return "iE_Extensions_t";}
24398 using parent_t = ProtocolExtensionContainer<WLANMeasurementConfiguration_ExtIEs>;
24399 static constexpr bool optional = true;
24402 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24403 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24404 template<typename V> void decode(V& v)
24407 v(wlanMeasConfigNameList);
24413 template<typename V> void encode(V& v) const
24416 v(wlanMeasConfigNameList);
24424 wlanMeasConfig.clear();
24425 wlanMeasConfigNameList.clear();
24428 iE_Extensions.clear();
24432 wlanMeasConfig_t wlanMeasConfig;
24433 wlanMeasConfigNameList_t wlanMeasConfigNameList;
24434 wlan_rssi_t wlan_rssi;
24435 wlan_rtt_t wlan_rtt;
24436 iE_Extensions_t iE_Extensions;
24440 MDT-Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24441 {ID id-M3Configuration CRITICALITY ignore EXTENSION M3Configuration PRESENCE conditional}|
24442 {ID id-M4Configuration CRITICALITY ignore EXTENSION M4Configuration PRESENCE conditional}|
24443 {ID id-M5Configuration CRITICALITY ignore EXTENSION M5Configuration PRESENCE conditional}|
24444 {ID id-MDT-Location-Info CRITICALITY ignore EXTENSION MDT-Location-Info PRESENCE optional}|
24445 {ID id-SignallingBasedMDTPLMNList CRITICALITY ignore EXTENSION MDTPLMNList PRESENCE optional}|
24446 {ID id-M6Configuration CRITICALITY ignore EXTENSION M6Configuration PRESENCE conditional}|
24447 {ID id-M7Configuration CRITICALITY ignore EXTENSION M7Configuration PRESENCE conditional}|
24448 { ID id-BluetoothMeasurementConfiguration CRITICALITY ignore EXTENSION BluetoothMeasurementConfiguration PRESENCE optional}|
24449 { ID id-WLANMeasurementConfiguration CRITICALITY ignore EXTENSION WLANMeasurementConfiguration PRESENCE optional},
24454 struct MDT_Configuration_ExtIEs
24456 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24458 size_t get_index() const {return type;}
24459 bool is_unknown() const { return type == 10; }
24460 void clear() {type = 0;}
24461 void select_id_M3Configuration() { set(id_M3Configuration); type=1;}
24462 void select_id_M4Configuration() { set(id_M4Configuration); type=2;}
24463 void select_id_M5Configuration() { set(id_M5Configuration); type=3;}
24464 void select_id_MDT_Location_Info() { set(id_MDT_Location_Info); type=4;}
24465 void select_id_SignallingBasedMDTPLMNList() { set(id_SignallingBasedMDTPLMNList); type=5;}
24466 void select_id_M6Configuration() { set(id_M6Configuration); type=6;}
24467 void select_id_M7Configuration() { set(id_M7Configuration); type=7;}
24468 void select_id_BluetoothMeasurementConfiguration() { set(id_BluetoothMeasurementConfiguration); type=8;}
24469 void select_id_WLANMeasurementConfiguration() { set(id_WLANMeasurementConfiguration); type=9;}
24470 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24471 template<typename V> bool decode(V& v)
24474 if(!v(ref_nested())) return false;
24475 if(equal(id_M3Configuration)) { type = 1; return true; }
24476 else if(equal(id_M4Configuration)) { type = 2; return true; }
24477 else if(equal(id_M5Configuration)) { type = 3; return true; }
24478 else if(equal(id_MDT_Location_Info)) { type = 4; return true; }
24479 else if(equal(id_SignallingBasedMDTPLMNList)) { type = 5; return true; }
24480 else if(equal(id_M6Configuration)) { type = 6; return true; }
24481 else if(equal(id_M7Configuration)) { type = 7; return true; }
24482 else if(equal(id_BluetoothMeasurementConfiguration)) { type = 8; return true; }
24483 else if(equal(id_WLANMeasurementConfiguration)) { type = 9; return true; }
24484 else { type = 10; return true;}
24488 template<typename V> bool encode(V& v) const
24490 return v(ref_nested());
24494 template<typename V> bool decode(size_t index, V& v)
24499 case 1: type = 1; if(v(ref_nested())) { return equal(id_M3Configuration);} return false;
24500 case 2: type = 2; if(v(ref_nested())) { return equal(id_M4Configuration);} return false;
24501 case 3: type = 3; if(v(ref_nested())) { return equal(id_M5Configuration);} return false;
24502 case 4: type = 4; if(v(ref_nested())) { return equal(id_MDT_Location_Info);} return false;
24503 case 5: type = 5; if(v(ref_nested())) { return equal(id_SignallingBasedMDTPLMNList);} return false;
24504 case 6: type = 6; if(v(ref_nested())) { return equal(id_M6Configuration);} return false;
24505 case 7: type = 7; if(v(ref_nested())) { return equal(id_M7Configuration);} return false;
24506 case 8: type = 8; if(v(ref_nested())) { return equal(id_BluetoothMeasurementConfiguration);} return false;
24507 case 9: type = 9; if(v(ref_nested())) { return equal(id_WLANMeasurementConfiguration);} return false;
24508 case 10: type = 10; return v(ref_nested());
24509 ref_nested().clear();
24514 template<typename V> bool encode(size_t index, V& v) const
24516 if(index != type) {return false;} return v(ref_nested());
24523 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
24525 size_t get_index() const {return type;}
24526 bool is_unknown() const { return type == 10; }
24527 void clear() {type = 0;}
24528 void select_id_M3Configuration() { set(ignore); type=1;}
24529 void select_id_M4Configuration() { set(ignore); type=2;}
24530 void select_id_M5Configuration() { set(ignore); type=3;}
24531 void select_id_MDT_Location_Info() { set(ignore); type=4;}
24532 void select_id_SignallingBasedMDTPLMNList() { set(ignore); type=5;}
24533 void select_id_M6Configuration() { set(ignore); type=6;}
24534 void select_id_M7Configuration() { set(ignore); type=7;}
24535 void select_id_BluetoothMeasurementConfiguration() { set(ignore); type=8;}
24536 void select_id_WLANMeasurementConfiguration() { set(ignore); type=9;}
24537 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
24538 template<typename V> bool decode(V& v)
24541 if(!v(ref_nested())) return false;
24542 if(equal(ignore)) { type = 1; return true; }
24543 else if(equal(ignore)) { type = 2; return true; }
24544 else if(equal(ignore)) { type = 3; return true; }
24545 else if(equal(ignore)) { type = 4; return true; }
24546 else if(equal(ignore)) { type = 5; return true; }
24547 else if(equal(ignore)) { type = 6; return true; }
24548 else if(equal(ignore)) { type = 7; return true; }
24549 else if(equal(ignore)) { type = 8; return true; }
24550 else if(equal(ignore)) { type = 9; return true; }
24551 else { type = 10; return true;}
24555 template<typename V> bool encode(V& v) const
24557 return v(ref_nested());
24561 template<typename V> bool decode(size_t index, V& v)
24566 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
24567 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
24568 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
24569 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
24570 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
24571 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
24572 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
24573 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
24574 case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
24575 case 10: type = 10; return v(ref_nested());
24576 ref_nested().clear();
24581 template<typename V> bool encode(size_t index, V& v) const
24583 if(index != type) {return false;} return v(ref_nested());
24590 struct Extension_t : asn::typefield<true>
24592 ~Extension_t() {clear();}
24593 size_t get_index() const {return type;}
24594 M3Configuration& select_id_M3Configuration() { return set<M3Configuration>(1); }
24595 M3Configuration const* get_id_M3Configuration() const { return get<M3Configuration>(1); }
24596 M4Configuration& select_id_M4Configuration() { return set<M4Configuration>(2); }
24597 M4Configuration const* get_id_M4Configuration() const { return get<M4Configuration>(2); }
24598 M5Configuration& select_id_M5Configuration() { return set<M5Configuration>(3); }
24599 M5Configuration const* get_id_M5Configuration() const { return get<M5Configuration>(3); }
24600 MDT_Location_Info& select_id_MDT_Location_Info() { return set<MDT_Location_Info>(4); }
24601 MDT_Location_Info const* get_id_MDT_Location_Info() const { return get<MDT_Location_Info>(4); }
24602 MDTPLMNList& select_id_SignallingBasedMDTPLMNList() { return set<MDTPLMNList>(5); }
24603 MDTPLMNList const* get_id_SignallingBasedMDTPLMNList() const { return get<MDTPLMNList>(5); }
24604 M6Configuration& select_id_M6Configuration() { return set<M6Configuration>(6); }
24605 M6Configuration const* get_id_M6Configuration() const { return get<M6Configuration>(6); }
24606 M7Configuration& select_id_M7Configuration() { return set<M7Configuration>(7); }
24607 M7Configuration const* get_id_M7Configuration() const { return get<M7Configuration>(7); }
24608 BluetoothMeasurementConfiguration& select_id_BluetoothMeasurementConfiguration() { return set<BluetoothMeasurementConfiguration>(8); }
24609 BluetoothMeasurementConfiguration const* get_id_BluetoothMeasurementConfiguration() const { return get<BluetoothMeasurementConfiguration>(8); }
24610 WLANMeasurementConfiguration& select_id_WLANMeasurementConfiguration() { return set<WLANMeasurementConfiguration>(9); }
24611 WLANMeasurementConfiguration const* get_id_WLANMeasurementConfiguration() const { return get<WLANMeasurementConfiguration>(9); }
24612 bool is_unknown() const { return type == 10; }
24617 case 1: var.destroy<M3Configuration>(); break;
24618 case 2: var.destroy<M4Configuration>(); break;
24619 case 3: var.destroy<M5Configuration>(); break;
24620 case 4: var.destroy<MDT_Location_Info>(); break;
24621 case 5: var.destroy<MDTPLMNList>(); break;
24622 case 6: var.destroy<M6Configuration>(); break;
24623 case 7: var.destroy<M7Configuration>(); break;
24624 case 8: var.destroy<BluetoothMeasurementConfiguration>(); break;
24625 case 9: var.destroy<WLANMeasurementConfiguration>(); break;
24627 type = 0; ref_nested().clear();
24629 template<typename V> static inline void enumerate(V& v)
24631 v.template operator()<M3Configuration>(1);
24632 v.template operator()<M4Configuration>(2);
24633 v.template operator()<M5Configuration>(3);
24634 v.template operator()<MDT_Location_Info>(4);
24635 v.template operator()<MDTPLMNList>(5);
24636 v.template operator()<M6Configuration>(6);
24637 v.template operator()<M7Configuration>(7);
24638 v.template operator()<BluetoothMeasurementConfiguration>(8);
24639 v.template operator()<WLANMeasurementConfiguration>(9);
24643 template<typename V> bool decode(size_t index, V& v)
24648 case 1: v(select_id_M3Configuration()); return true;
24649 case 2: v(select_id_M4Configuration()); return true;
24650 case 3: v(select_id_M5Configuration()); return true;
24651 case 4: v(select_id_MDT_Location_Info()); return true;
24652 case 5: v(select_id_SignallingBasedMDTPLMNList()); return true;
24653 case 6: v(select_id_M6Configuration()); return true;
24654 case 7: v(select_id_M7Configuration()); return true;
24655 case 8: v(select_id_BluetoothMeasurementConfiguration()); return true;
24656 case 9: v(select_id_WLANMeasurementConfiguration()); return true;
24657 case 10: if(type != 10) {clear(); asn::base::set();} type = 10; return true;
24662 template<typename V> bool encode(size_t index, V& v) const
24664 if(index != type) return false;
24667 case 1: v(var.as<M3Configuration>()); return true;
24668 case 2: v(var.as<M4Configuration>()); return true;
24669 case 3: v(var.as<M5Configuration>()); return true;
24670 case 4: v(var.as<MDT_Location_Info>()); return true;
24671 case 5: v(var.as<MDTPLMNList>()); return true;
24672 case 6: v(var.as<M6Configuration>()); return true;
24673 case 7: v(var.as<M7Configuration>()); return true;
24674 case 8: v(var.as<BluetoothMeasurementConfiguration>()); return true;
24675 case 9: v(var.as<WLANMeasurementConfiguration>()); return true;
24681 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
24682 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
24685 char dummy1[sizeof(BluetoothMeasurementConfiguration)];
24686 char dummy2[sizeof(M3Configuration)];
24687 char dummy3[sizeof(M4Configuration)];
24688 char dummy4[sizeof(M5Configuration)];
24689 char dummy5[sizeof(M6Configuration)];
24690 char dummy6[sizeof(M7Configuration)];
24691 char dummy7[sizeof(MDTPLMNList)];
24692 char dummy8[sizeof(MDT_Location_Info)];
24693 char dummy9[sizeof(WLANMeasurementConfiguration)];
24696 asn::variant<sizeof(union_type)> var;
24700 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
24702 size_t get_index() const {return type;}
24703 bool is_unknown() const { return type == 10; }
24704 void clear() {type = 0;}
24705 void select_id_M3Configuration() { set(conditional); type=1;}
24706 void select_id_M4Configuration() { set(conditional); type=2;}
24707 void select_id_M5Configuration() { set(conditional); type=3;}
24708 void select_id_MDT_Location_Info() { set(optional); type=4;}
24709 void select_id_SignallingBasedMDTPLMNList() { set(optional); type=5;}
24710 void select_id_M6Configuration() { set(conditional); type=6;}
24711 void select_id_M7Configuration() { set(conditional); type=7;}
24712 void select_id_BluetoothMeasurementConfiguration() { set(optional); type=8;}
24713 void select_id_WLANMeasurementConfiguration() { set(optional); type=9;}
24714 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
24715 template<typename V> bool decode(V& v)
24718 if(!v(ref_nested())) return false;
24719 if(equal(conditional)) { type = 1; return true; }
24720 else if(equal(conditional)) { type = 2; return true; }
24721 else if(equal(conditional)) { type = 3; return true; }
24722 else if(equal(optional)) { type = 4; return true; }
24723 else if(equal(optional)) { type = 5; return true; }
24724 else if(equal(conditional)) { type = 6; return true; }
24725 else if(equal(conditional)) { type = 7; return true; }
24726 else if(equal(optional)) { type = 8; return true; }
24727 else if(equal(optional)) { type = 9; return true; }
24728 else { type = 10; return true;}
24732 template<typename V> bool encode(V& v) const
24734 return v(ref_nested());
24738 template<typename V> bool decode(size_t index, V& v)
24743 case 1: type = 1; if(v(ref_nested())) { return equal(conditional);} return false;
24744 case 2: type = 2; if(v(ref_nested())) { return equal(conditional);} return false;
24745 case 3: type = 3; if(v(ref_nested())) { return equal(conditional);} return false;
24746 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
24747 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
24748 case 6: type = 6; if(v(ref_nested())) { return equal(conditional);} return false;
24749 case 7: type = 7; if(v(ref_nested())) { return equal(conditional);} return false;
24750 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
24751 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
24752 case 10: type = 10; return v(ref_nested());
24753 ref_nested().clear();
24758 template<typename V> bool encode(size_t index, V& v) const
24760 if(index != type) {return false;} return v(ref_nested());
24770 MDT-Configuration ::= SEQUENCE {
24771 mdt-Activation MDT-Activation,
24772 areaScopeOfMDT AreaScopeOfMDT,
24773 measurementsToActivate MeasurementsToActivate,
24774 m1reportingTrigger M1ReportingTrigger,
24775 m1thresholdeventA2 M1ThresholdEventA2 OPTIONAL,
24776 -- Included in case of event-triggered, or event-triggered periodic reporting for measurement M1
24777 m1periodicReporting M1PeriodicReporting OPTIONAL,
24778 -- Included in case of periodic, or event-triggered periodic reporting for measurement M1
24779 iE-Extensions ProtocolExtensionContainer { {MDT-Configuration-ExtIEs} } OPTIONAL,
24784 struct MDT_Configuration : asn::sequence<7, 0, true, 3>
24786 static constexpr const char* name() {return "MDT-Configuration";}
24787 using parent_t = asn::sequence<7, 0, true, 3>;
24788 struct mdt_Activation_t : MDT_Activation
24790 static constexpr const char* name() {return "mdt_Activation_t";}
24791 using parent_t = MDT_Activation;
24794 mdt_Activation_t& ref_mdt_Activation() {return mdt_Activation;}
24795 mdt_Activation_t const& ref_mdt_Activation() const {return mdt_Activation;}
24796 struct areaScopeOfMDT_t : AreaScopeOfMDT
24798 static constexpr const char* name() {return "areaScopeOfMDT_t";}
24799 using parent_t = AreaScopeOfMDT;
24802 areaScopeOfMDT_t& ref_areaScopeOfMDT() {return areaScopeOfMDT;}
24803 areaScopeOfMDT_t const& ref_areaScopeOfMDT() const {return areaScopeOfMDT;}
24804 struct measurementsToActivate_t : MeasurementsToActivate
24806 static constexpr const char* name() {return "measurementsToActivate_t";}
24807 using parent_t = MeasurementsToActivate;
24810 measurementsToActivate_t& ref_measurementsToActivate() {return measurementsToActivate;}
24811 measurementsToActivate_t const& ref_measurementsToActivate() const {return measurementsToActivate;}
24812 struct m1reportingTrigger_t : M1ReportingTrigger
24814 static constexpr const char* name() {return "m1reportingTrigger_t";}
24815 using parent_t = M1ReportingTrigger;
24818 m1reportingTrigger_t& ref_m1reportingTrigger() {return m1reportingTrigger;}
24819 m1reportingTrigger_t const& ref_m1reportingTrigger() const {return m1reportingTrigger;}
24820 struct m1thresholdeventA2_t : M1ThresholdEventA2
24822 static constexpr const char* name() {return "m1thresholdeventA2_t";}
24823 using parent_t = M1ThresholdEventA2;
24824 static constexpr bool optional = true;
24827 m1thresholdeventA2_t& set_m1thresholdeventA2() { m1thresholdeventA2.setpresent(true); return m1thresholdeventA2;}
24828 m1thresholdeventA2_t const* get_m1thresholdeventA2() const {return m1thresholdeventA2.is_valid() ? &m1thresholdeventA2 : nullptr;}
24829 struct m1periodicReporting_t : M1PeriodicReporting
24831 static constexpr const char* name() {return "m1periodicReporting_t";}
24832 using parent_t = M1PeriodicReporting;
24833 static constexpr bool optional = true;
24836 m1periodicReporting_t& set_m1periodicReporting() { m1periodicReporting.setpresent(true); return m1periodicReporting;}
24837 m1periodicReporting_t const* get_m1periodicReporting() const {return m1periodicReporting.is_valid() ? &m1periodicReporting : nullptr;}
24838 struct iE_Extensions_t : ProtocolExtensionContainer<MDT_Configuration_ExtIEs>
24840 static constexpr const char* name() {return "iE_Extensions_t";}
24841 using parent_t = ProtocolExtensionContainer<MDT_Configuration_ExtIEs>;
24842 static constexpr bool optional = true;
24845 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
24846 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
24847 template<typename V> void decode(V& v)
24851 v(measurementsToActivate);
24852 v(m1reportingTrigger);
24853 v(m1thresholdeventA2);
24854 v(m1periodicReporting);
24858 template<typename V> void encode(V& v) const
24862 v(measurementsToActivate);
24863 v(m1reportingTrigger);
24864 v(m1thresholdeventA2);
24865 v(m1periodicReporting);
24871 mdt_Activation.clear();
24872 areaScopeOfMDT.clear();
24873 measurementsToActivate.clear();
24874 m1reportingTrigger.clear();
24875 m1thresholdeventA2.clear();
24876 m1periodicReporting.clear();
24877 iE_Extensions.clear();
24881 mdt_Activation_t mdt_Activation;
24882 areaScopeOfMDT_t areaScopeOfMDT;
24883 measurementsToActivate_t measurementsToActivate;
24884 m1reportingTrigger_t m1reportingTrigger;
24885 m1thresholdeventA2_t m1thresholdeventA2;
24886 m1periodicReporting_t m1periodicReporting;
24887 iE_Extensions_t iE_Extensions;
24891 MakeBeforeBreakIndicator::= ENUMERATED {true, ...}
24894 struct MakeBeforeBreakIndicator : asn::enumerated<1, 0, true>
24896 static constexpr const char* name() {return "MakeBeforeBreakIndicator";}
24897 using parent_t = asn::enumerated<1, 0, true>;
24905 ManagementBasedMDTallowed ::= ENUMERATED {allowed, ...}
24908 struct ManagementBasedMDTallowed : asn::enumerated<1, 0, true>
24910 static constexpr const char* name() {return "ManagementBasedMDTallowed";}
24911 using parent_t = asn::enumerated<1, 0, true>;
24919 Masked-IMEISV ::= BIT STRING (SIZE (64))
24922 struct Masked_IMEISV : asn::bstring<>
24924 using constraint_t = asn::constraints<false,asn::one<64>>;
24925 static constexpr const char* name() {return "Masked-IMEISV";}
24926 using parent_t = asn::bstring<>;
24931 MeNBCoordinationAssistanceInformation ::= ENUMERATED{
24932 coordination-not-required,
24937 struct MeNBCoordinationAssistanceInformation : asn::enumerated<1, 0, true>
24939 static constexpr const char* name() {return "MeNBCoordinationAssistanceInformation";}
24940 using parent_t = asn::enumerated<1, 0, true>;
24942 coordination_not_required
24948 NRCellIdentifier ::= BIT STRING (SIZE (36))
24951 struct NRCellIdentifier : asn::bstring<>
24953 using constraint_t = asn::constraints<false,asn::one<36>>;
24954 static constexpr const char* name() {return "NRCellIdentifier";}
24955 using parent_t = asn::bstring<>;
24960 NRCGI-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
24965 struct NRCGI_ExtIEs
24967 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
24969 size_t get_index() const {return type;}
24970 bool is_unknown() const { return type == 1; }
24971 void clear() {type = 0;}
24972 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
24973 template<typename V> bool decode(V& v)
24976 if(!v(ref_nested())) return false;
24977 { type = 1; return true;}
24981 template<typename V> bool encode(V& v) const
24983 return v(ref_nested());
24987 template<typename V> bool decode(size_t index, V& v)
24992 case 1: type = 1; return v(ref_nested());
24993 ref_nested().clear();
24998 template<typename V> bool encode(size_t index, V& v) const
25000 if(index != type) {return false;} return v(ref_nested());
25007 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25009 size_t get_index() const {return type;}
25010 bool is_unknown() const { return type == 1; }
25011 void clear() {type = 0;}
25012 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25013 template<typename V> bool decode(V& v)
25016 if(!v(ref_nested())) return false;
25017 { type = 1; return true;}
25021 template<typename V> bool encode(V& v) const
25023 return v(ref_nested());
25027 template<typename V> bool decode(size_t index, V& v)
25032 case 1: type = 1; return v(ref_nested());
25033 ref_nested().clear();
25038 template<typename V> bool encode(size_t index, V& v) const
25040 if(index != type) {return false;} return v(ref_nested());
25047 struct Extension_t : asn::typefield<true>
25049 ~Extension_t() {clear();}
25050 size_t get_index() const {return type;}
25051 bool is_unknown() const { return type == 1; }
25054 type = 0; ref_nested().clear();
25056 template<typename V> static inline void enumerate(V& v)
25061 template<typename V> bool decode(size_t index, V& v)
25066 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
25071 template<typename V> bool encode(size_t index, V& v) const
25073 if(index != type) return false;
25081 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25083 size_t get_index() const {return type;}
25084 bool is_unknown() const { return type == 1; }
25085 void clear() {type = 0;}
25086 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25087 template<typename V> bool decode(V& v)
25090 if(!v(ref_nested())) return false;
25091 { type = 1; return true;}
25095 template<typename V> bool encode(V& v) const
25097 return v(ref_nested());
25101 template<typename V> bool decode(size_t index, V& v)
25106 case 1: type = 1; return v(ref_nested());
25107 ref_nested().clear();
25112 template<typename V> bool encode(size_t index, V& v) const
25114 if(index != type) {return false;} return v(ref_nested());
25124 NRCGI ::= SEQUENCE {
25125 pLMN-Identity PLMN-Identity,
25126 nRcellIdentifier NRCellIdentifier,
25127 iE-Extensions ProtocolExtensionContainer { {NRCGI-ExtIEs} } OPTIONAL,
25132 struct NRCGI : asn::sequence<3, 0, true, 1>
25134 static constexpr const char* name() {return "NRCGI";}
25135 using parent_t = asn::sequence<3, 0, true, 1>;
25136 struct pLMN_Identity_t : PLMN_Identity
25138 static constexpr const char* name() {return "pLMN_Identity_t";}
25139 using parent_t = PLMN_Identity;
25142 pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
25143 pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
25144 struct nRcellIdentifier_t : NRCellIdentifier
25146 static constexpr const char* name() {return "nRcellIdentifier_t";}
25147 using parent_t = NRCellIdentifier;
25150 nRcellIdentifier_t& ref_nRcellIdentifier() {return nRcellIdentifier;}
25151 nRcellIdentifier_t const& ref_nRcellIdentifier() const {return nRcellIdentifier;}
25152 struct iE_Extensions_t : ProtocolExtensionContainer<NRCGI_ExtIEs>
25154 static constexpr const char* name() {return "iE_Extensions_t";}
25155 using parent_t = ProtocolExtensionContainer<NRCGI_ExtIEs>;
25156 static constexpr bool optional = true;
25159 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25160 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25161 template<typename V> void decode(V& v)
25164 v(nRcellIdentifier);
25168 template<typename V> void encode(V& v) const
25171 v(nRcellIdentifier);
25177 pLMN_Identity.clear();
25178 nRcellIdentifier.clear();
25179 iE_Extensions.clear();
25183 pLMN_Identity_t pLMN_Identity;
25184 nRcellIdentifier_t nRcellIdentifier;
25185 iE_Extensions_t iE_Extensions;
25189 MeNBResourceCoordinationInformationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25190 { ID id-NRCGI CRITICALITY ignore EXTENSION NRCGI PRESENCE optional}|
25191 { ID id-MeNBCoordinationAssistanceInformation CRITICALITY reject EXTENSION MeNBCoordinationAssistanceInformation PRESENCE optional},
25196 struct MeNBResourceCoordinationInformationExtIEs
25198 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25200 size_t get_index() const {return type;}
25201 bool is_unknown() const { return type == 3; }
25202 void clear() {type = 0;}
25203 void select_id_NRCGI() { set(id_NRCGI); type=1;}
25204 void select_id_MeNBCoordinationAssistanceInformation() { set(id_MeNBCoordinationAssistanceInformation); type=2;}
25205 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25206 template<typename V> bool decode(V& v)
25209 if(!v(ref_nested())) return false;
25210 if(equal(id_NRCGI)) { type = 1; return true; }
25211 else if(equal(id_MeNBCoordinationAssistanceInformation)) { type = 2; return true; }
25212 else { type = 3; return true;}
25216 template<typename V> bool encode(V& v) const
25218 return v(ref_nested());
25222 template<typename V> bool decode(size_t index, V& v)
25227 case 1: type = 1; if(v(ref_nested())) { return equal(id_NRCGI);} return false;
25228 case 2: type = 2; if(v(ref_nested())) { return equal(id_MeNBCoordinationAssistanceInformation);} return false;
25229 case 3: type = 3; return v(ref_nested());
25230 ref_nested().clear();
25235 template<typename V> bool encode(size_t index, V& v) const
25237 if(index != type) {return false;} return v(ref_nested());
25244 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25246 size_t get_index() const {return type;}
25247 bool is_unknown() const { return type == 3; }
25248 void clear() {type = 0;}
25249 void select_id_NRCGI() { set(ignore); type=1;}
25250 void select_id_MeNBCoordinationAssistanceInformation() { set(reject); type=2;}
25251 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25252 template<typename V> bool decode(V& v)
25255 if(!v(ref_nested())) return false;
25256 if(equal(ignore)) { type = 1; return true; }
25257 else if(equal(reject)) { type = 2; return true; }
25258 else { type = 3; return true;}
25262 template<typename V> bool encode(V& v) const
25264 return v(ref_nested());
25268 template<typename V> bool decode(size_t index, V& v)
25273 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
25274 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
25275 case 3: type = 3; return v(ref_nested());
25276 ref_nested().clear();
25281 template<typename V> bool encode(size_t index, V& v) const
25283 if(index != type) {return false;} return v(ref_nested());
25290 struct Extension_t : asn::typefield<true>
25292 ~Extension_t() {clear();}
25293 size_t get_index() const {return type;}
25294 NRCGI& select_id_NRCGI() { return set<NRCGI>(1); }
25295 NRCGI const* get_id_NRCGI() const { return get<NRCGI>(1); }
25296 MeNBCoordinationAssistanceInformation& select_id_MeNBCoordinationAssistanceInformation() { return set<MeNBCoordinationAssistanceInformation>(2); }
25297 MeNBCoordinationAssistanceInformation const* get_id_MeNBCoordinationAssistanceInformation() const { return get<MeNBCoordinationAssistanceInformation>(2); }
25298 bool is_unknown() const { return type == 3; }
25303 case 1: var.destroy<NRCGI>(); break;
25304 case 2: var.destroy<MeNBCoordinationAssistanceInformation>(); break;
25306 type = 0; ref_nested().clear();
25308 template<typename V> static inline void enumerate(V& v)
25310 v.template operator()<NRCGI>(1);
25311 v.template operator()<MeNBCoordinationAssistanceInformation>(2);
25315 template<typename V> bool decode(size_t index, V& v)
25320 case 1: v(select_id_NRCGI()); return true;
25321 case 2: v(select_id_MeNBCoordinationAssistanceInformation()); return true;
25322 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
25327 template<typename V> bool encode(size_t index, V& v) const
25329 if(index != type) return false;
25332 case 1: v(var.as<NRCGI>()); return true;
25333 case 2: v(var.as<MeNBCoordinationAssistanceInformation>()); return true;
25339 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
25340 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
25343 char dummy1[sizeof(MeNBCoordinationAssistanceInformation)];
25344 char dummy2[sizeof(NRCGI)];
25347 asn::variant<sizeof(union_type)> var;
25351 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25353 size_t get_index() const {return type;}
25354 bool is_unknown() const { return type == 3; }
25355 void clear() {type = 0;}
25356 void select_id_NRCGI() { set(optional); type=1;}
25357 void select_id_MeNBCoordinationAssistanceInformation() { set(optional); type=2;}
25358 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25359 template<typename V> bool decode(V& v)
25362 if(!v(ref_nested())) return false;
25363 if(equal(optional)) { type = 1; return true; }
25364 else if(equal(optional)) { type = 2; return true; }
25365 else { type = 3; return true;}
25369 template<typename V> bool encode(V& v) const
25371 return v(ref_nested());
25375 template<typename V> bool decode(size_t index, V& v)
25380 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
25381 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
25382 case 3: type = 3; return v(ref_nested());
25383 ref_nested().clear();
25388 template<typename V> bool encode(size_t index, V& v) const
25390 if(index != type) {return false;} return v(ref_nested());
25400 MeNBResourceCoordinationInformation ::= SEQUENCE {
25401 eUTRA-Cell-ID ECGI,
25402 uLCoordinationInformation BIT STRING (SIZE(6..4400, ...)),
25403 dLCoordinationInformation BIT STRING (SIZE(6..4400, ...)) OPTIONAL,
25404 iE-Extensions ProtocolExtensionContainer { {MeNBResourceCoordinationInformationExtIEs} } OPTIONAL,
25409 struct MeNBResourceCoordinationInformation : asn::sequence<4, 0, true, 2>
25411 static constexpr const char* name() {return "MeNBResourceCoordinationInformation";}
25412 using parent_t = asn::sequence<4, 0, true, 2>;
25413 struct eUTRA_Cell_ID_t : ECGI
25415 static constexpr const char* name() {return "eUTRA_Cell_ID_t";}
25416 using parent_t = ECGI;
25419 eUTRA_Cell_ID_t& ref_eUTRA_Cell_ID() {return eUTRA_Cell_ID;}
25420 eUTRA_Cell_ID_t const& ref_eUTRA_Cell_ID() const {return eUTRA_Cell_ID;}
25421 struct uLCoordinationInformation_t : asn::bstring<>
25423 using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
25424 static constexpr const char* name() {return "uLCoordinationInformation_t";}
25425 using parent_t = asn::bstring<>;
25429 uLCoordinationInformation_t& ref_uLCoordinationInformation() {return uLCoordinationInformation;}
25430 uLCoordinationInformation_t const& ref_uLCoordinationInformation() const {return uLCoordinationInformation;}
25431 struct dLCoordinationInformation_t : asn::bstring<>
25433 using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
25434 static constexpr const char* name() {return "dLCoordinationInformation_t";}
25435 using parent_t = asn::bstring<>;
25436 static constexpr bool optional = true;
25440 dLCoordinationInformation_t& set_dLCoordinationInformation() { dLCoordinationInformation.setpresent(true); return dLCoordinationInformation;}
25441 dLCoordinationInformation_t const* get_dLCoordinationInformation() const {return dLCoordinationInformation.is_valid() ? &dLCoordinationInformation : nullptr;}
25442 struct iE_Extensions_t : ProtocolExtensionContainer<MeNBResourceCoordinationInformationExtIEs>
25444 static constexpr const char* name() {return "iE_Extensions_t";}
25445 using parent_t = ProtocolExtensionContainer<MeNBResourceCoordinationInformationExtIEs>;
25446 static constexpr bool optional = true;
25449 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25450 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25451 template<typename V> void decode(V& v)
25454 v(uLCoordinationInformation);
25455 v(dLCoordinationInformation);
25459 template<typename V> void encode(V& v) const
25462 v(uLCoordinationInformation);
25463 v(dLCoordinationInformation);
25469 eUTRA_Cell_ID.clear();
25470 uLCoordinationInformation.clear();
25471 dLCoordinationInformation.clear();
25472 iE_Extensions.clear();
25476 eUTRA_Cell_ID_t eUTRA_Cell_ID;
25477 uLCoordinationInformation_t uLCoordinationInformation;
25478 dLCoordinationInformation_t dLCoordinationInformation;
25479 iE_Extensions_t iE_Extensions;
25483 MeNBtoSeNBContainer ::= OCTET STRING
25486 struct MeNBtoSeNBContainer : asn::ostring<>
25488 static constexpr const char* name() {return "MeNBtoSeNBContainer";}
25489 using parent_t = asn::ostring<>;
25494 MeNBtoSgNBContainer ::= OCTET STRING
25497 struct MeNBtoSgNBContainer : asn::ostring<>
25499 static constexpr const char* name() {return "MeNBtoSgNBContainer";}
25500 using parent_t = asn::ostring<>;
25505 Measurement-ID ::= INTEGER (1..4095, ...)
25508 struct Measurement_ID : asn::integer<>
25510 using constraint_t = asn::constraints<true,asn::span<1, 4095>>;
25511 static constexpr const char* name() {return "Measurement-ID";}
25512 using parent_t = asn::integer<>;
25517 MobilityParametersInformation ::= SEQUENCE {
25518 handoverTriggerChange INTEGER (-20..20),
25523 struct MobilityParametersInformation : asn::sequence<1, 0, true, 0>
25525 static constexpr const char* name() {return "MobilityParametersInformation";}
25526 using parent_t = asn::sequence<1, 0, true, 0>;
25527 struct handoverTriggerChange_t : asn::integer<>
25529 using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
25530 static constexpr const char* name() {return "handoverTriggerChange_t";}
25531 using parent_t = asn::integer<>;
25535 handoverTriggerChange_t& ref_handoverTriggerChange() {return handoverTriggerChange;}
25536 handoverTriggerChange_t const& ref_handoverTriggerChange() const {return handoverTriggerChange;}
25537 template<typename V> void decode(V& v)
25539 v(handoverTriggerChange);
25542 template<typename V> void encode(V& v) const
25544 v(handoverTriggerChange);
25549 handoverTriggerChange.clear();
25553 handoverTriggerChange_t handoverTriggerChange;
25557 MobilityParametersModificationRange ::= SEQUENCE {
25558 handoverTriggerChangeLowerLimit INTEGER (-20..20),
25559 handoverTriggerChangeUpperLimit INTEGER (-20..20),
25564 struct MobilityParametersModificationRange : asn::sequence<2, 0, true, 0>
25566 static constexpr const char* name() {return "MobilityParametersModificationRange";}
25567 using parent_t = asn::sequence<2, 0, true, 0>;
25568 struct handoverTriggerChangeLowerLimit_t : asn::integer<>
25570 using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
25571 static constexpr const char* name() {return "handoverTriggerChangeLowerLimit_t";}
25572 using parent_t = asn::integer<>;
25576 handoverTriggerChangeLowerLimit_t& ref_handoverTriggerChangeLowerLimit() {return handoverTriggerChangeLowerLimit;}
25577 handoverTriggerChangeLowerLimit_t const& ref_handoverTriggerChangeLowerLimit() const {return handoverTriggerChangeLowerLimit;}
25578 struct handoverTriggerChangeUpperLimit_t : asn::integer<>
25580 using constraint_t = asn::constraints<false,asn::span<-20, 20>>;
25581 static constexpr const char* name() {return "handoverTriggerChangeUpperLimit_t";}
25582 using parent_t = asn::integer<>;
25586 handoverTriggerChangeUpperLimit_t& ref_handoverTriggerChangeUpperLimit() {return handoverTriggerChangeUpperLimit;}
25587 handoverTriggerChangeUpperLimit_t const& ref_handoverTriggerChangeUpperLimit() const {return handoverTriggerChangeUpperLimit;}
25588 template<typename V> void decode(V& v)
25590 v(handoverTriggerChangeLowerLimit);
25591 v(handoverTriggerChangeUpperLimit);
25594 template<typename V> void encode(V& v) const
25596 v(handoverTriggerChangeLowerLimit);
25597 v(handoverTriggerChangeUpperLimit);
25602 handoverTriggerChangeLowerLimit.clear();
25603 handoverTriggerChangeUpperLimit.clear();
25607 handoverTriggerChangeLowerLimit_t handoverTriggerChangeLowerLimit;
25608 handoverTriggerChangeUpperLimit_t handoverTriggerChangeUpperLimit;
25612 MultibandInfoList ::= SEQUENCE (SIZE(1..maxnoofBands)) OF BandInfo
25615 struct MultibandInfoList_elm : BandInfo
25617 static constexpr const char* name() {return "MultibandInfoList_elm";}
25618 using parent_t = BandInfo;
25621 struct MultibandInfoList : asn::sequenceof<MultibandInfoList_elm>
25623 static constexpr const char* name() {return "MultibandInfoList";}
25624 using parent_t = asn::sequenceof<MultibandInfoList_elm>;
25625 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBands >>;
25629 NRSCS ::= ENUMERATED { scs15, scs30, scs60, scs120, ...}
25632 struct NRSCS : asn::enumerated<4, 0, true>
25634 static constexpr const char* name() {return "NRSCS";}
25635 using parent_t = asn::enumerated<4, 0, true>;
25646 NRNRB ::= ENUMERATED { nrb11, nrb18, nrb24, nrb25, nrb31, nrb32, nrb38, nrb51, nrb52, nrb65, nrb66, nrb78, nrb79, nrb93, nrb106, nrb107, nrb121, nrb132, nrb133, nrb135, nrb160, nrb162, nrb189, nrb216, nrb217, nrb245, nrb264, nrb270, nrb273, ...}
25649 struct NRNRB : asn::enumerated<29, 0, true>
25651 static constexpr const char* name() {return "NRNRB";}
25652 using parent_t = asn::enumerated<29, 0, true>;
25688 NR-TxBW-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25693 struct NR_TxBW_ExtIEs
25695 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25697 size_t get_index() const {return type;}
25698 bool is_unknown() const { return type == 1; }
25699 void clear() {type = 0;}
25700 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25701 template<typename V> bool decode(V& v)
25704 if(!v(ref_nested())) return false;
25705 { type = 1; return true;}
25709 template<typename V> bool encode(V& v) const
25711 return v(ref_nested());
25715 template<typename V> bool decode(size_t index, V& v)
25720 case 1: type = 1; return v(ref_nested());
25721 ref_nested().clear();
25726 template<typename V> bool encode(size_t index, V& v) const
25728 if(index != type) {return false;} return v(ref_nested());
25735 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25737 size_t get_index() const {return type;}
25738 bool is_unknown() const { return type == 1; }
25739 void clear() {type = 0;}
25740 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25741 template<typename V> bool decode(V& v)
25744 if(!v(ref_nested())) return false;
25745 { type = 1; return true;}
25749 template<typename V> bool encode(V& v) const
25751 return v(ref_nested());
25755 template<typename V> bool decode(size_t index, V& v)
25760 case 1: type = 1; return v(ref_nested());
25761 ref_nested().clear();
25766 template<typename V> bool encode(size_t index, V& v) const
25768 if(index != type) {return false;} return v(ref_nested());
25775 struct Extension_t : asn::typefield<true>
25777 ~Extension_t() {clear();}
25778 size_t get_index() const {return type;}
25779 bool is_unknown() const { return type == 1; }
25782 type = 0; ref_nested().clear();
25784 template<typename V> static inline void enumerate(V& v)
25789 template<typename V> bool decode(size_t index, V& v)
25794 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
25799 template<typename V> bool encode(size_t index, V& v) const
25801 if(index != type) return false;
25809 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
25811 size_t get_index() const {return type;}
25812 bool is_unknown() const { return type == 1; }
25813 void clear() {type = 0;}
25814 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
25815 template<typename V> bool decode(V& v)
25818 if(!v(ref_nested())) return false;
25819 { type = 1; return true;}
25823 template<typename V> bool encode(V& v) const
25825 return v(ref_nested());
25829 template<typename V> bool decode(size_t index, V& v)
25834 case 1: type = 1; return v(ref_nested());
25835 ref_nested().clear();
25840 template<typename V> bool encode(size_t index, V& v) const
25842 if(index != type) {return false;} return v(ref_nested());
25852 NR-TxBW ::= SEQUENCE {
25855 iE-Extensions ProtocolExtensionContainer { {NR-TxBW-ExtIEs} } OPTIONAL,
25860 struct NR_TxBW : asn::sequence<3, 0, true, 1>
25862 static constexpr const char* name() {return "NR-TxBW";}
25863 using parent_t = asn::sequence<3, 0, true, 1>;
25864 struct nRSCS_t : NRSCS
25866 static constexpr const char* name() {return "nRSCS_t";}
25867 using parent_t = NRSCS;
25870 nRSCS_t& ref_nRSCS() {return nRSCS;}
25871 nRSCS_t const& ref_nRSCS() const {return nRSCS;}
25872 struct nRNRB_t : NRNRB
25874 static constexpr const char* name() {return "nRNRB_t";}
25875 using parent_t = NRNRB;
25878 nRNRB_t& ref_nRNRB() {return nRNRB;}
25879 nRNRB_t const& ref_nRNRB() const {return nRNRB;}
25880 struct iE_Extensions_t : ProtocolExtensionContainer<NR_TxBW_ExtIEs>
25882 static constexpr const char* name() {return "iE_Extensions_t";}
25883 using parent_t = ProtocolExtensionContainer<NR_TxBW_ExtIEs>;
25884 static constexpr bool optional = true;
25887 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
25888 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
25889 template<typename V> void decode(V& v)
25896 template<typename V> void encode(V& v) const
25907 iE_Extensions.clear();
25913 iE_Extensions_t iE_Extensions;
25917 SULInformation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
25922 struct SULInformation_ExtIEs
25924 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
25926 size_t get_index() const {return type;}
25927 bool is_unknown() const { return type == 1; }
25928 void clear() {type = 0;}
25929 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
25930 template<typename V> bool decode(V& v)
25933 if(!v(ref_nested())) return false;
25934 { type = 1; return true;}
25938 template<typename V> bool encode(V& v) const
25940 return v(ref_nested());
25944 template<typename V> bool decode(size_t index, V& v)
25949 case 1: type = 1; return v(ref_nested());
25950 ref_nested().clear();
25955 template<typename V> bool encode(size_t index, V& v) const
25957 if(index != type) {return false;} return v(ref_nested());
25964 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
25966 size_t get_index() const {return type;}
25967 bool is_unknown() const { return type == 1; }
25968 void clear() {type = 0;}
25969 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
25970 template<typename V> bool decode(V& v)
25973 if(!v(ref_nested())) return false;
25974 { type = 1; return true;}
25978 template<typename V> bool encode(V& v) const
25980 return v(ref_nested());
25984 template<typename V> bool decode(size_t index, V& v)
25989 case 1: type = 1; return v(ref_nested());
25990 ref_nested().clear();
25995 template<typename V> bool encode(size_t index, V& v) const
25997 if(index != type) {return false;} return v(ref_nested());
26004 struct Extension_t : asn::typefield<true>
26006 ~Extension_t() {clear();}
26007 size_t get_index() const {return type;}
26008 bool is_unknown() const { return type == 1; }
26011 type = 0; ref_nested().clear();
26013 template<typename V> static inline void enumerate(V& v)
26018 template<typename V> bool decode(size_t index, V& v)
26023 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26028 template<typename V> bool encode(size_t index, V& v) const
26030 if(index != type) return false;
26038 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26040 size_t get_index() const {return type;}
26041 bool is_unknown() const { return type == 1; }
26042 void clear() {type = 0;}
26043 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26044 template<typename V> bool decode(V& v)
26047 if(!v(ref_nested())) return false;
26048 { type = 1; return true;}
26052 template<typename V> bool encode(V& v) const
26054 return v(ref_nested());
26058 template<typename V> bool decode(size_t index, V& v)
26063 case 1: type = 1; return v(ref_nested());
26064 ref_nested().clear();
26069 template<typename V> bool encode(size_t index, V& v) const
26071 if(index != type) {return false;} return v(ref_nested());
26081 SULInformation ::= SEQUENCE {
26082 sUL-ARFCN INTEGER (0.. 3279165),
26084 iE-Extensions ProtocolExtensionContainer { {SULInformation-ExtIEs} } OPTIONAL,
26089 struct SULInformation : asn::sequence<3, 0, true, 1>
26091 static constexpr const char* name() {return "SULInformation";}
26092 using parent_t = asn::sequence<3, 0, true, 1>;
26093 struct sUL_ARFCN_t : asn::integer<>
26095 using constraint_t = asn::constraints<false,asn::span<0, 3279165>>;
26096 static constexpr const char* name() {return "sUL_ARFCN_t";}
26097 using parent_t = asn::integer<>;
26101 sUL_ARFCN_t& ref_sUL_ARFCN() {return sUL_ARFCN;}
26102 sUL_ARFCN_t const& ref_sUL_ARFCN() const {return sUL_ARFCN;}
26103 struct sUL_TxBW_t : NR_TxBW
26105 static constexpr const char* name() {return "sUL_TxBW_t";}
26106 using parent_t = NR_TxBW;
26109 sUL_TxBW_t& ref_sUL_TxBW() {return sUL_TxBW;}
26110 sUL_TxBW_t const& ref_sUL_TxBW() const {return sUL_TxBW;}
26111 struct iE_Extensions_t : ProtocolExtensionContainer<SULInformation_ExtIEs>
26113 static constexpr const char* name() {return "iE_Extensions_t";}
26114 using parent_t = ProtocolExtensionContainer<SULInformation_ExtIEs>;
26115 static constexpr bool optional = true;
26118 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26119 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26120 template<typename V> void decode(V& v)
26127 template<typename V> void encode(V& v) const
26138 iE_Extensions.clear();
26142 sUL_ARFCN_t sUL_ARFCN;
26143 sUL_TxBW_t sUL_TxBW;
26144 iE_Extensions_t iE_Extensions;
26148 NRFreqInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26153 struct NRFreqInfo_ExtIEs
26155 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26157 size_t get_index() const {return type;}
26158 bool is_unknown() const { return type == 1; }
26159 void clear() {type = 0;}
26160 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26161 template<typename V> bool decode(V& v)
26164 if(!v(ref_nested())) return false;
26165 { type = 1; return true;}
26169 template<typename V> bool encode(V& v) const
26171 return v(ref_nested());
26175 template<typename V> bool decode(size_t index, V& v)
26180 case 1: type = 1; return v(ref_nested());
26181 ref_nested().clear();
26186 template<typename V> bool encode(size_t index, V& v) const
26188 if(index != type) {return false;} return v(ref_nested());
26195 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26197 size_t get_index() const {return type;}
26198 bool is_unknown() const { return type == 1; }
26199 void clear() {type = 0;}
26200 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26201 template<typename V> bool decode(V& v)
26204 if(!v(ref_nested())) return false;
26205 { type = 1; return true;}
26209 template<typename V> bool encode(V& v) const
26211 return v(ref_nested());
26215 template<typename V> bool decode(size_t index, V& v)
26220 case 1: type = 1; return v(ref_nested());
26221 ref_nested().clear();
26226 template<typename V> bool encode(size_t index, V& v) const
26228 if(index != type) {return false;} return v(ref_nested());
26235 struct Extension_t : asn::typefield<true>
26237 ~Extension_t() {clear();}
26238 size_t get_index() const {return type;}
26239 bool is_unknown() const { return type == 1; }
26242 type = 0; ref_nested().clear();
26244 template<typename V> static inline void enumerate(V& v)
26249 template<typename V> bool decode(size_t index, V& v)
26254 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26259 template<typename V> bool encode(size_t index, V& v) const
26261 if(index != type) return false;
26269 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26271 size_t get_index() const {return type;}
26272 bool is_unknown() const { return type == 1; }
26273 void clear() {type = 0;}
26274 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26275 template<typename V> bool decode(V& v)
26278 if(!v(ref_nested())) return false;
26279 { type = 1; return true;}
26283 template<typename V> bool encode(V& v) const
26285 return v(ref_nested());
26289 template<typename V> bool decode(size_t index, V& v)
26294 case 1: type = 1; return v(ref_nested());
26295 ref_nested().clear();
26300 template<typename V> bool encode(size_t index, V& v) const
26302 if(index != type) {return false;} return v(ref_nested());
26312 NRFreqInfo ::= SEQUENCE{
26313 nRARFCN INTEGER (0.. 3279165),
26314 freqBandListNr SEQUENCE (SIZE(1..maxnoofNrCellBands)) OF FreqBandNrItem,
26315 sULInformation SULInformation OPTIONAL,
26316 iE-Extensions ProtocolExtensionContainer { {NRFreqInfo-ExtIEs} } OPTIONAL,
26322 struct NRFreqInfo : asn::sequence<4, 0, true, 2>
26324 static constexpr const char* name() {return "NRFreqInfo";}
26325 using parent_t = asn::sequence<4, 0, true, 2>;
26326 struct nRARFCN_t : asn::integer<>
26328 using constraint_t = asn::constraints<false,asn::span<0, 3279165>>;
26329 static constexpr const char* name() {return "nRARFCN_t";}
26330 using parent_t = asn::integer<>;
26334 nRARFCN_t& ref_nRARFCN() {return nRARFCN;}
26335 nRARFCN_t const& ref_nRARFCN() const {return nRARFCN;}
26336 struct freqBandListNr_t_elm : FreqBandNrItem
26338 static constexpr const char* name() {return "freqBandListNr_t_elm";}
26339 using parent_t = FreqBandNrItem;
26342 struct freqBandListNr_t : asn::sequenceof<freqBandListNr_t_elm>
26344 static constexpr const char* name() {return "freqBandListNr_t";}
26345 using parent_t = asn::sequenceof<freqBandListNr_t_elm>;
26346 using constraint_t = asn::constraints<false,asn::span<1, maxnoofNrCellBands >>;
26349 freqBandListNr_t& ref_freqBandListNr() {return freqBandListNr;}
26350 freqBandListNr_t const& ref_freqBandListNr() const {return freqBandListNr;}
26351 struct sULInformation_t : SULInformation
26353 static constexpr const char* name() {return "sULInformation_t";}
26354 using parent_t = SULInformation;
26355 static constexpr bool optional = true;
26358 sULInformation_t& set_sULInformation() { sULInformation.setpresent(true); return sULInformation;}
26359 sULInformation_t const* get_sULInformation() const {return sULInformation.is_valid() ? &sULInformation : nullptr;}
26360 struct iE_Extensions_t : ProtocolExtensionContainer<NRFreqInfo_ExtIEs>
26362 static constexpr const char* name() {return "iE_Extensions_t";}
26363 using parent_t = ProtocolExtensionContainer<NRFreqInfo_ExtIEs>;
26364 static constexpr bool optional = true;
26367 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26368 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26369 template<typename V> void decode(V& v)
26377 template<typename V> void encode(V& v) const
26388 freqBandListNr.clear();
26389 sULInformation.clear();
26390 iE_Extensions.clear();
26395 freqBandListNr_t freqBandListNr;
26396 sULInformation_t sULInformation;
26397 iE_Extensions_t iE_Extensions;
26401 NRPCI ::= INTEGER (0..1007)
26404 struct NRPCI : asn::integer<>
26406 using constraint_t = asn::constraints<false,asn::span<0, 1007>>;
26407 static constexpr const char* name() {return "NRPCI";}
26408 using parent_t = asn::integer<>;
26413 NRencryptionAlgorithms ::= BIT STRING (SIZE (16,...))
26416 struct NRencryptionAlgorithms : asn::bstring<>
26418 using constraint_t = asn::constraints<true,asn::one<16>>;
26419 static constexpr const char* name() {return "NRencryptionAlgorithms";}
26420 using parent_t = asn::bstring<>;
26425 NRintegrityProtectionAlgorithms ::= BIT STRING (SIZE (16,...))
26428 struct NRintegrityProtectionAlgorithms : asn::bstring<>
26430 using constraint_t = asn::constraints<true,asn::one<16>>;
26431 static constexpr const char* name() {return "NRintegrityProtectionAlgorithms";}
26432 using parent_t = asn::bstring<>;
26437 NRUESecurityCapabilities-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26442 struct NRUESecurityCapabilities_ExtIEs
26444 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26446 size_t get_index() const {return type;}
26447 bool is_unknown() const { return type == 1; }
26448 void clear() {type = 0;}
26449 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26450 template<typename V> bool decode(V& v)
26453 if(!v(ref_nested())) return false;
26454 { type = 1; return true;}
26458 template<typename V> bool encode(V& v) const
26460 return v(ref_nested());
26464 template<typename V> bool decode(size_t index, V& v)
26469 case 1: type = 1; return v(ref_nested());
26470 ref_nested().clear();
26475 template<typename V> bool encode(size_t index, V& v) const
26477 if(index != type) {return false;} return v(ref_nested());
26484 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26486 size_t get_index() const {return type;}
26487 bool is_unknown() const { return type == 1; }
26488 void clear() {type = 0;}
26489 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26490 template<typename V> bool decode(V& v)
26493 if(!v(ref_nested())) return false;
26494 { type = 1; return true;}
26498 template<typename V> bool encode(V& v) const
26500 return v(ref_nested());
26504 template<typename V> bool decode(size_t index, V& v)
26509 case 1: type = 1; return v(ref_nested());
26510 ref_nested().clear();
26515 template<typename V> bool encode(size_t index, V& v) const
26517 if(index != type) {return false;} return v(ref_nested());
26524 struct Extension_t : asn::typefield<true>
26526 ~Extension_t() {clear();}
26527 size_t get_index() const {return type;}
26528 bool is_unknown() const { return type == 1; }
26531 type = 0; ref_nested().clear();
26533 template<typename V> static inline void enumerate(V& v)
26538 template<typename V> bool decode(size_t index, V& v)
26543 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
26548 template<typename V> bool encode(size_t index, V& v) const
26550 if(index != type) return false;
26558 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26560 size_t get_index() const {return type;}
26561 bool is_unknown() const { return type == 1; }
26562 void clear() {type = 0;}
26563 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26564 template<typename V> bool decode(V& v)
26567 if(!v(ref_nested())) return false;
26568 { type = 1; return true;}
26572 template<typename V> bool encode(V& v) const
26574 return v(ref_nested());
26578 template<typename V> bool decode(size_t index, V& v)
26583 case 1: type = 1; return v(ref_nested());
26584 ref_nested().clear();
26589 template<typename V> bool encode(size_t index, V& v) const
26591 if(index != type) {return false;} return v(ref_nested());
26601 NRUESecurityCapabilities ::= SEQUENCE {
26602 nRencryptionAlgorithms NRencryptionAlgorithms,
26603 nRintegrityProtectionAlgorithms NRintegrityProtectionAlgorithms,
26604 iE-Extensions ProtocolExtensionContainer { {NRUESecurityCapabilities-ExtIEs} } OPTIONAL,
26609 struct NRUESecurityCapabilities : asn::sequence<3, 0, true, 1>
26611 static constexpr const char* name() {return "NRUESecurityCapabilities";}
26612 using parent_t = asn::sequence<3, 0, true, 1>;
26613 struct nRencryptionAlgorithms_t : NRencryptionAlgorithms
26615 static constexpr const char* name() {return "nRencryptionAlgorithms_t";}
26616 using parent_t = NRencryptionAlgorithms;
26619 nRencryptionAlgorithms_t& ref_nRencryptionAlgorithms() {return nRencryptionAlgorithms;}
26620 nRencryptionAlgorithms_t const& ref_nRencryptionAlgorithms() const {return nRencryptionAlgorithms;}
26621 struct nRintegrityProtectionAlgorithms_t : NRintegrityProtectionAlgorithms
26623 static constexpr const char* name() {return "nRintegrityProtectionAlgorithms_t";}
26624 using parent_t = NRintegrityProtectionAlgorithms;
26627 nRintegrityProtectionAlgorithms_t& ref_nRintegrityProtectionAlgorithms() {return nRintegrityProtectionAlgorithms;}
26628 nRintegrityProtectionAlgorithms_t const& ref_nRintegrityProtectionAlgorithms() const {return nRintegrityProtectionAlgorithms;}
26629 struct iE_Extensions_t : ProtocolExtensionContainer<NRUESecurityCapabilities_ExtIEs>
26631 static constexpr const char* name() {return "iE_Extensions_t";}
26632 using parent_t = ProtocolExtensionContainer<NRUESecurityCapabilities_ExtIEs>;
26633 static constexpr bool optional = true;
26636 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26637 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26638 template<typename V> void decode(V& v)
26640 v(nRencryptionAlgorithms);
26641 v(nRintegrityProtectionAlgorithms);
26645 template<typename V> void encode(V& v) const
26647 v(nRencryptionAlgorithms);
26648 v(nRintegrityProtectionAlgorithms);
26654 nRencryptionAlgorithms.clear();
26655 nRintegrityProtectionAlgorithms.clear();
26656 iE_Extensions.clear();
26660 nRencryptionAlgorithms_t nRencryptionAlgorithms;
26661 nRintegrityProtectionAlgorithms_t nRintegrityProtectionAlgorithms;
26662 iE_Extensions_t iE_Extensions;
26666 PCI ::= INTEGER (0..503, ...)
26669 struct PCI : asn::integer<>
26671 using constraint_t = asn::constraints<true,asn::span<0, 503>>;
26672 static constexpr const char* name() {return "PCI";}
26673 using parent_t = asn::integer<>;
26678 Neighbour-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
26679 { ID id-NeighbourTAC CRITICALITY ignore EXTENSION TAC PRESENCE optional}|
26680 { ID id-eARFCNExtension CRITICALITY reject EXTENSION EARFCNExtension PRESENCE optional},
26685 struct Neighbour_Information_ExtIEs
26687 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
26689 size_t get_index() const {return type;}
26690 bool is_unknown() const { return type == 3; }
26691 void clear() {type = 0;}
26692 void select_id_NeighbourTAC() { set(id_NeighbourTAC); type=1;}
26693 void select_id_eARFCNExtension() { set(id_eARFCNExtension); type=2;}
26694 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
26695 template<typename V> bool decode(V& v)
26698 if(!v(ref_nested())) return false;
26699 if(equal(id_NeighbourTAC)) { type = 1; return true; }
26700 else if(equal(id_eARFCNExtension)) { type = 2; return true; }
26701 else { type = 3; return true;}
26705 template<typename V> bool encode(V& v) const
26707 return v(ref_nested());
26711 template<typename V> bool decode(size_t index, V& v)
26716 case 1: type = 1; if(v(ref_nested())) { return equal(id_NeighbourTAC);} return false;
26717 case 2: type = 2; if(v(ref_nested())) { return equal(id_eARFCNExtension);} return false;
26718 case 3: type = 3; return v(ref_nested());
26719 ref_nested().clear();
26724 template<typename V> bool encode(size_t index, V& v) const
26726 if(index != type) {return false;} return v(ref_nested());
26733 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
26735 size_t get_index() const {return type;}
26736 bool is_unknown() const { return type == 3; }
26737 void clear() {type = 0;}
26738 void select_id_NeighbourTAC() { set(ignore); type=1;}
26739 void select_id_eARFCNExtension() { set(reject); type=2;}
26740 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
26741 template<typename V> bool decode(V& v)
26744 if(!v(ref_nested())) return false;
26745 if(equal(ignore)) { type = 1; return true; }
26746 else if(equal(reject)) { type = 2; return true; }
26747 else { type = 3; return true;}
26751 template<typename V> bool encode(V& v) const
26753 return v(ref_nested());
26757 template<typename V> bool decode(size_t index, V& v)
26762 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
26763 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
26764 case 3: type = 3; return v(ref_nested());
26765 ref_nested().clear();
26770 template<typename V> bool encode(size_t index, V& v) const
26772 if(index != type) {return false;} return v(ref_nested());
26779 struct Extension_t : asn::typefield<true>
26781 ~Extension_t() {clear();}
26782 size_t get_index() const {return type;}
26783 TAC& select_id_NeighbourTAC() { return set<TAC>(1); }
26784 TAC const* get_id_NeighbourTAC() const { return get<TAC>(1); }
26785 EARFCNExtension& select_id_eARFCNExtension() { return set<EARFCNExtension>(2); }
26786 EARFCNExtension const* get_id_eARFCNExtension() const { return get<EARFCNExtension>(2); }
26787 bool is_unknown() const { return type == 3; }
26792 case 1: var.destroy<TAC>(); break;
26793 case 2: var.destroy<EARFCNExtension>(); break;
26795 type = 0; ref_nested().clear();
26797 template<typename V> static inline void enumerate(V& v)
26799 v.template operator()<TAC>(1);
26800 v.template operator()<EARFCNExtension>(2);
26804 template<typename V> bool decode(size_t index, V& v)
26809 case 1: v(select_id_NeighbourTAC()); return true;
26810 case 2: v(select_id_eARFCNExtension()); return true;
26811 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
26816 template<typename V> bool encode(size_t index, V& v) const
26818 if(index != type) return false;
26821 case 1: v(var.as<TAC>()); return true;
26822 case 2: v(var.as<EARFCNExtension>()); return true;
26828 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
26829 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
26832 char dummy1[sizeof(EARFCNExtension)];
26833 char dummy2[sizeof(TAC)];
26836 asn::variant<sizeof(union_type)> var;
26840 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
26842 size_t get_index() const {return type;}
26843 bool is_unknown() const { return type == 3; }
26844 void clear() {type = 0;}
26845 void select_id_NeighbourTAC() { set(optional); type=1;}
26846 void select_id_eARFCNExtension() { set(optional); type=2;}
26847 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
26848 template<typename V> bool decode(V& v)
26851 if(!v(ref_nested())) return false;
26852 if(equal(optional)) { type = 1; return true; }
26853 else if(equal(optional)) { type = 2; return true; }
26854 else { type = 3; return true;}
26858 template<typename V> bool encode(V& v) const
26860 return v(ref_nested());
26864 template<typename V> bool decode(size_t index, V& v)
26869 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
26870 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
26871 case 3: type = 3; return v(ref_nested());
26872 ref_nested().clear();
26877 template<typename V> bool encode(size_t index, V& v) const
26879 if(index != type) {return false;} return v(ref_nested());
26889 Neighbour-Information ::= SEQUENCE (SIZE (0..maxnoofNeighbours)) OF SEQUENCE {
26893 iE-Extensions ProtocolExtensionContainer { {Neighbour-Information-ExtIEs} } OPTIONAL,
26898 struct Neighbour_Information_elm : asn::sequence<4, 0, true, 1>
26900 static constexpr const char* name() {return "Neighbour_Information_elm";}
26901 using parent_t = asn::sequence<4, 0, true, 1>;
26902 struct eCGI_t : ECGI
26904 static constexpr const char* name() {return "eCGI_t";}
26905 using parent_t = ECGI;
26908 eCGI_t& ref_eCGI() {return eCGI;}
26909 eCGI_t const& ref_eCGI() const {return eCGI;}
26912 static constexpr const char* name() {return "pCI_t";}
26913 using parent_t = PCI;
26916 pCI_t& ref_pCI() {return pCI;}
26917 pCI_t const& ref_pCI() const {return pCI;}
26918 struct eARFCN_t : EARFCN
26920 static constexpr const char* name() {return "eARFCN_t";}
26921 using parent_t = EARFCN;
26924 eARFCN_t& ref_eARFCN() {return eARFCN;}
26925 eARFCN_t const& ref_eARFCN() const {return eARFCN;}
26926 struct iE_Extensions_t : ProtocolExtensionContainer<Neighbour_Information_ExtIEs>
26928 static constexpr const char* name() {return "iE_Extensions_t";}
26929 using parent_t = ProtocolExtensionContainer<Neighbour_Information_ExtIEs>;
26930 static constexpr bool optional = true;
26933 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
26934 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
26935 template<typename V> void decode(V& v)
26943 template<typename V> void encode(V& v) const
26956 iE_Extensions.clear();
26963 iE_Extensions_t iE_Extensions;
26966 struct Neighbour_Information : asn::sequenceof<Neighbour_Information_elm>
26968 static constexpr const char* name() {return "Neighbour-Information";}
26969 using parent_t = asn::sequenceof<Neighbour_Information_elm>;
26970 using constraint_t = asn::constraints<false,asn::span<0, maxnoofNeighbours >>;
26974 NewDRBIDrequest::= ENUMERATED {true, ...}
26977 struct NewDRBIDrequest : asn::enumerated<1, 0, true>
26979 static constexpr const char* name() {return "NewDRBIDrequest";}
26980 using parent_t = asn::enumerated<1, 0, true>;
26988 Number-of-Antennaports ::= ENUMERATED {
26996 struct Number_of_Antennaports : asn::enumerated<3, 0, true>
26998 static constexpr const char* name() {return "Number-of-Antennaports";}
26999 using parent_t = asn::enumerated<3, 0, true>;
27009 PDCPChangeIndication ::= ENUMERATED {s-KgNB-update-required, pDCP-data-recovery-required,...}
27012 struct PDCPChangeIndication : asn::enumerated<2, 0, true>
27014 static constexpr const char* name() {return "PDCPChangeIndication";}
27015 using parent_t = asn::enumerated<2, 0, true>;
27017 s_KgNB_update_required
27018 ,pDCP_data_recovery_required
27024 PDCPSnLength ::= ENUMERATED {twelve-bits,eighteen-bits,...}
27027 struct PDCPSnLength : asn::enumerated<2, 0, true>
27029 static constexpr const char* name() {return "PDCPSnLength";}
27030 using parent_t = asn::enumerated<2, 0, true>;
27039 PRACH-Configuration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27044 struct PRACH_Configuration_ExtIEs
27046 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27048 size_t get_index() const {return type;}
27049 bool is_unknown() const { return type == 1; }
27050 void clear() {type = 0;}
27051 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27052 template<typename V> bool decode(V& v)
27055 if(!v(ref_nested())) return false;
27056 { type = 1; return true;}
27060 template<typename V> bool encode(V& v) const
27062 return v(ref_nested());
27066 template<typename V> bool decode(size_t index, V& v)
27071 case 1: type = 1; return v(ref_nested());
27072 ref_nested().clear();
27077 template<typename V> bool encode(size_t index, V& v) const
27079 if(index != type) {return false;} return v(ref_nested());
27086 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27088 size_t get_index() const {return type;}
27089 bool is_unknown() const { return type == 1; }
27090 void clear() {type = 0;}
27091 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27092 template<typename V> bool decode(V& v)
27095 if(!v(ref_nested())) return false;
27096 { type = 1; return true;}
27100 template<typename V> bool encode(V& v) const
27102 return v(ref_nested());
27106 template<typename V> bool decode(size_t index, V& v)
27111 case 1: type = 1; return v(ref_nested());
27112 ref_nested().clear();
27117 template<typename V> bool encode(size_t index, V& v) const
27119 if(index != type) {return false;} return v(ref_nested());
27126 struct Extension_t : asn::typefield<true>
27128 ~Extension_t() {clear();}
27129 size_t get_index() const {return type;}
27130 bool is_unknown() const { return type == 1; }
27133 type = 0; ref_nested().clear();
27135 template<typename V> static inline void enumerate(V& v)
27140 template<typename V> bool decode(size_t index, V& v)
27145 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
27150 template<typename V> bool encode(size_t index, V& v) const
27152 if(index != type) return false;
27160 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27162 size_t get_index() const {return type;}
27163 bool is_unknown() const { return type == 1; }
27164 void clear() {type = 0;}
27165 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27166 template<typename V> bool decode(V& v)
27169 if(!v(ref_nested())) return false;
27170 { type = 1; return true;}
27174 template<typename V> bool encode(V& v) const
27176 return v(ref_nested());
27180 template<typename V> bool decode(size_t index, V& v)
27185 case 1: type = 1; return v(ref_nested());
27186 ref_nested().clear();
27191 template<typename V> bool encode(size_t index, V& v) const
27193 if(index != type) {return false;} return v(ref_nested());
27203 PRACH-Configuration ::= SEQUENCE {
27204 rootSequenceIndex INTEGER (0..837),
27205 zeroCorrelationIndex INTEGER (0..15),
27206 highSpeedFlag BOOLEAN,
27207 prach-FreqOffset INTEGER (0..94),
27208 prach-ConfigIndex INTEGER (0..63) OPTIONAL, -- present for TDD --
27209 iE-Extensions ProtocolExtensionContainer { {PRACH-Configuration-ExtIEs} } OPTIONAL,
27214 struct PRACH_Configuration : asn::sequence<6, 0, true, 2>
27216 static constexpr const char* name() {return "PRACH-Configuration";}
27217 using parent_t = asn::sequence<6, 0, true, 2>;
27218 struct rootSequenceIndex_t : asn::integer<>
27220 using constraint_t = asn::constraints<false,asn::span<0, 837>>;
27221 static constexpr const char* name() {return "rootSequenceIndex_t";}
27222 using parent_t = asn::integer<>;
27226 rootSequenceIndex_t& ref_rootSequenceIndex() {return rootSequenceIndex;}
27227 rootSequenceIndex_t const& ref_rootSequenceIndex() const {return rootSequenceIndex;}
27228 struct zeroCorrelationIndex_t : asn::integer<>
27230 using constraint_t = asn::constraints<false,asn::span<0, 15>>;
27231 static constexpr const char* name() {return "zeroCorrelationIndex_t";}
27232 using parent_t = asn::integer<>;
27236 zeroCorrelationIndex_t& ref_zeroCorrelationIndex() {return zeroCorrelationIndex;}
27237 zeroCorrelationIndex_t const& ref_zeroCorrelationIndex() const {return zeroCorrelationIndex;}
27238 struct highSpeedFlag_t : asn::boolean
27240 static constexpr const char* name() {return "highSpeedFlag_t";}
27241 using parent_t = asn::boolean;
27244 highSpeedFlag_t& ref_highSpeedFlag() {return highSpeedFlag;}
27245 highSpeedFlag_t const& ref_highSpeedFlag() const {return highSpeedFlag;}
27246 struct prach_FreqOffset_t : asn::integer<>
27248 using constraint_t = asn::constraints<false,asn::span<0, 94>>;
27249 static constexpr const char* name() {return "prach_FreqOffset_t";}
27250 using parent_t = asn::integer<>;
27254 prach_FreqOffset_t& ref_prach_FreqOffset() {return prach_FreqOffset;}
27255 prach_FreqOffset_t const& ref_prach_FreqOffset() const {return prach_FreqOffset;}
27256 struct prach_ConfigIndex_t : asn::integer<>
27258 using constraint_t = asn::constraints<false,asn::span<0, 63>>;
27259 static constexpr const char* name() {return "prach_ConfigIndex_t";}
27260 using parent_t = asn::integer<>;
27261 static constexpr bool optional = true;
27265 prach_ConfigIndex_t& set_prach_ConfigIndex() { prach_ConfigIndex.setpresent(true); return prach_ConfigIndex;}
27266 prach_ConfigIndex_t const* get_prach_ConfigIndex() const {return prach_ConfigIndex.is_valid() ? &prach_ConfigIndex : nullptr;}
27267 struct iE_Extensions_t : ProtocolExtensionContainer<PRACH_Configuration_ExtIEs>
27269 static constexpr const char* name() {return "iE_Extensions_t";}
27270 using parent_t = ProtocolExtensionContainer<PRACH_Configuration_ExtIEs>;
27271 static constexpr bool optional = true;
27274 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
27275 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
27276 template<typename V> void decode(V& v)
27278 v(rootSequenceIndex);
27279 v(zeroCorrelationIndex);
27281 v(prach_FreqOffset);
27282 v(prach_ConfigIndex);
27286 template<typename V> void encode(V& v) const
27288 v(rootSequenceIndex);
27289 v(zeroCorrelationIndex);
27291 v(prach_FreqOffset);
27292 v(prach_ConfigIndex);
27298 rootSequenceIndex.clear();
27299 zeroCorrelationIndex.clear();
27300 highSpeedFlag.clear();
27301 prach_FreqOffset.clear();
27302 prach_ConfigIndex.clear();
27303 iE_Extensions.clear();
27307 rootSequenceIndex_t rootSequenceIndex;
27308 zeroCorrelationIndex_t zeroCorrelationIndex;
27309 highSpeedFlag_t highSpeedFlag;
27310 prach_FreqOffset_t prach_FreqOffset;
27311 prach_ConfigIndex_t prach_ConfigIndex;
27312 iE_Extensions_t iE_Extensions;
27316 PedestrianUE ::= ENUMERATED {
27323 struct PedestrianUE : asn::enumerated<2, 0, true>
27325 static constexpr const char* name() {return "PedestrianUE";}
27326 using parent_t = asn::enumerated<2, 0, true>;
27335 Port-Number ::= OCTET STRING (SIZE (2))
27338 struct Port_Number : asn::ostring<>
27340 using constraint_t = asn::constraints<false,asn::one<2>>;
27341 static constexpr const char* name() {return "Port-Number";}
27342 using parent_t = asn::ostring<>;
27347 ProSeDirectDiscovery ::= ENUMERATED {
27354 struct ProSeDirectDiscovery : asn::enumerated<2, 0, true>
27356 static constexpr const char* name() {return "ProSeDirectDiscovery";}
27357 using parent_t = asn::enumerated<2, 0, true>;
27366 ProSeDirectCommunication ::= ENUMERATED {
27373 struct ProSeDirectCommunication : asn::enumerated<2, 0, true>
27375 static constexpr const char* name() {return "ProSeDirectCommunication";}
27376 using parent_t = asn::enumerated<2, 0, true>;
27385 ProSeUEtoNetworkRelaying ::= ENUMERATED {
27392 struct ProSeUEtoNetworkRelaying : asn::enumerated<2, 0, true>
27394 static constexpr const char* name() {return "ProSeUEtoNetworkRelaying";}
27395 using parent_t = asn::enumerated<2, 0, true>;
27404 ProSeAuthorized-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27405 { ID id-ProSeUEtoNetworkRelaying CRITICALITY ignore EXTENSION ProSeUEtoNetworkRelaying PRESENCE optional},
27410 struct ProSeAuthorized_ExtIEs
27412 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27414 size_t get_index() const {return type;}
27415 bool is_unknown() const { return type == 2; }
27416 void clear() {type = 0;}
27417 void select_id_ProSeUEtoNetworkRelaying() { set(id_ProSeUEtoNetworkRelaying); type=1;}
27418 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27419 template<typename V> bool decode(V& v)
27422 if(!v(ref_nested())) return false;
27423 if(equal(id_ProSeUEtoNetworkRelaying)) { type = 1; return true; }
27424 else { type = 2; return true;}
27428 template<typename V> bool encode(V& v) const
27430 return v(ref_nested());
27434 template<typename V> bool decode(size_t index, V& v)
27439 case 1: type = 1; if(v(ref_nested())) { return equal(id_ProSeUEtoNetworkRelaying);} return false;
27440 case 2: type = 2; return v(ref_nested());
27441 ref_nested().clear();
27446 template<typename V> bool encode(size_t index, V& v) const
27448 if(index != type) {return false;} return v(ref_nested());
27455 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27457 size_t get_index() const {return type;}
27458 bool is_unknown() const { return type == 2; }
27459 void clear() {type = 0;}
27460 void select_id_ProSeUEtoNetworkRelaying() { set(ignore); type=1;}
27461 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27462 template<typename V> bool decode(V& v)
27465 if(!v(ref_nested())) return false;
27466 if(equal(ignore)) { type = 1; return true; }
27467 else { type = 2; return true;}
27471 template<typename V> bool encode(V& v) const
27473 return v(ref_nested());
27477 template<typename V> bool decode(size_t index, V& v)
27482 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
27483 case 2: type = 2; return v(ref_nested());
27484 ref_nested().clear();
27489 template<typename V> bool encode(size_t index, V& v) const
27491 if(index != type) {return false;} return v(ref_nested());
27498 struct Extension_t : asn::typefield<true>
27500 ~Extension_t() {clear();}
27501 size_t get_index() const {return type;}
27502 ProSeUEtoNetworkRelaying& select_id_ProSeUEtoNetworkRelaying() { return set<ProSeUEtoNetworkRelaying>(1); }
27503 ProSeUEtoNetworkRelaying const* get_id_ProSeUEtoNetworkRelaying() const { return get<ProSeUEtoNetworkRelaying>(1); }
27504 bool is_unknown() const { return type == 2; }
27509 case 1: var.destroy<ProSeUEtoNetworkRelaying>(); break;
27511 type = 0; ref_nested().clear();
27513 template<typename V> static inline void enumerate(V& v)
27515 v.template operator()<ProSeUEtoNetworkRelaying>(1);
27519 template<typename V> bool decode(size_t index, V& v)
27524 case 1: v(select_id_ProSeUEtoNetworkRelaying()); return true;
27525 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
27530 template<typename V> bool encode(size_t index, V& v) const
27532 if(index != type) return false;
27535 case 1: v(var.as<ProSeUEtoNetworkRelaying>()); return true;
27541 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
27542 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
27545 char dummy1[sizeof(ProSeUEtoNetworkRelaying)];
27548 asn::variant<sizeof(union_type)> var;
27552 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27554 size_t get_index() const {return type;}
27555 bool is_unknown() const { return type == 2; }
27556 void clear() {type = 0;}
27557 void select_id_ProSeUEtoNetworkRelaying() { set(optional); type=1;}
27558 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27559 template<typename V> bool decode(V& v)
27562 if(!v(ref_nested())) return false;
27563 if(equal(optional)) { type = 1; return true; }
27564 else { type = 2; return true;}
27568 template<typename V> bool encode(V& v) const
27570 return v(ref_nested());
27574 template<typename V> bool decode(size_t index, V& v)
27579 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
27580 case 2: type = 2; return v(ref_nested());
27581 ref_nested().clear();
27586 template<typename V> bool encode(size_t index, V& v) const
27588 if(index != type) {return false;} return v(ref_nested());
27598 ProSeAuthorized ::= SEQUENCE {
27599 proSeDirectDiscovery ProSeDirectDiscovery OPTIONAL,
27600 proSeDirectCommunication ProSeDirectCommunication OPTIONAL,
27601 iE-Extensions ProtocolExtensionContainer { {ProSeAuthorized-ExtIEs} } OPTIONAL,
27606 struct ProSeAuthorized : asn::sequence<3, 0, true, 3>
27608 static constexpr const char* name() {return "ProSeAuthorized";}
27609 using parent_t = asn::sequence<3, 0, true, 3>;
27610 struct proSeDirectDiscovery_t : ProSeDirectDiscovery
27612 static constexpr const char* name() {return "proSeDirectDiscovery_t";}
27613 using parent_t = ProSeDirectDiscovery;
27614 static constexpr bool optional = true;
27617 proSeDirectDiscovery_t& set_proSeDirectDiscovery() { proSeDirectDiscovery.setpresent(true); return proSeDirectDiscovery;}
27618 proSeDirectDiscovery_t const* get_proSeDirectDiscovery() const {return proSeDirectDiscovery.is_valid() ? &proSeDirectDiscovery : nullptr;}
27619 struct proSeDirectCommunication_t : ProSeDirectCommunication
27621 static constexpr const char* name() {return "proSeDirectCommunication_t";}
27622 using parent_t = ProSeDirectCommunication;
27623 static constexpr bool optional = true;
27626 proSeDirectCommunication_t& set_proSeDirectCommunication() { proSeDirectCommunication.setpresent(true); return proSeDirectCommunication;}
27627 proSeDirectCommunication_t const* get_proSeDirectCommunication() const {return proSeDirectCommunication.is_valid() ? &proSeDirectCommunication : nullptr;}
27628 struct iE_Extensions_t : ProtocolExtensionContainer<ProSeAuthorized_ExtIEs>
27630 static constexpr const char* name() {return "iE_Extensions_t";}
27631 using parent_t = ProtocolExtensionContainer<ProSeAuthorized_ExtIEs>;
27632 static constexpr bool optional = true;
27635 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
27636 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
27637 template<typename V> void decode(V& v)
27639 v(proSeDirectDiscovery);
27640 v(proSeDirectCommunication);
27644 template<typename V> void encode(V& v) const
27646 v(proSeDirectDiscovery);
27647 v(proSeDirectCommunication);
27653 proSeDirectDiscovery.clear();
27654 proSeDirectCommunication.clear();
27655 iE_Extensions.clear();
27659 proSeDirectDiscovery_t proSeDirectDiscovery;
27660 proSeDirectCommunication_t proSeDirectCommunication;
27661 iE_Extensions_t iE_Extensions;
27665 ResourceType ::= ENUMERATED {
27673 struct ResourceType : asn::enumerated<3, 0, true>
27675 static constexpr const char* name() {return "ResourceType";}
27676 using parent_t = asn::enumerated<3, 0, true>;
27686 ProtectedFootprintTimePattern-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27691 struct ProtectedFootprintTimePattern_ExtIEs
27693 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27695 size_t get_index() const {return type;}
27696 bool is_unknown() const { return type == 1; }
27697 void clear() {type = 0;}
27698 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27699 template<typename V> bool decode(V& v)
27702 if(!v(ref_nested())) return false;
27703 { type = 1; return true;}
27707 template<typename V> bool encode(V& v) const
27709 return v(ref_nested());
27713 template<typename V> bool decode(size_t index, V& v)
27718 case 1: type = 1; return v(ref_nested());
27719 ref_nested().clear();
27724 template<typename V> bool encode(size_t index, V& v) const
27726 if(index != type) {return false;} return v(ref_nested());
27733 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27735 size_t get_index() const {return type;}
27736 bool is_unknown() const { return type == 1; }
27737 void clear() {type = 0;}
27738 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27739 template<typename V> bool decode(V& v)
27742 if(!v(ref_nested())) return false;
27743 { type = 1; return true;}
27747 template<typename V> bool encode(V& v) const
27749 return v(ref_nested());
27753 template<typename V> bool decode(size_t index, V& v)
27758 case 1: type = 1; return v(ref_nested());
27759 ref_nested().clear();
27764 template<typename V> bool encode(size_t index, V& v) const
27766 if(index != type) {return false;} return v(ref_nested());
27773 struct Extension_t : asn::typefield<true>
27775 ~Extension_t() {clear();}
27776 size_t get_index() const {return type;}
27777 bool is_unknown() const { return type == 1; }
27780 type = 0; ref_nested().clear();
27782 template<typename V> static inline void enumerate(V& v)
27787 template<typename V> bool decode(size_t index, V& v)
27792 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
27797 template<typename V> bool encode(size_t index, V& v) const
27799 if(index != type) return false;
27807 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
27809 size_t get_index() const {return type;}
27810 bool is_unknown() const { return type == 1; }
27811 void clear() {type = 0;}
27812 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
27813 template<typename V> bool decode(V& v)
27816 if(!v(ref_nested())) return false;
27817 { type = 1; return true;}
27821 template<typename V> bool encode(V& v) const
27823 return v(ref_nested());
27827 template<typename V> bool decode(size_t index, V& v)
27832 case 1: type = 1; return v(ref_nested());
27833 ref_nested().clear();
27838 template<typename V> bool encode(size_t index, V& v) const
27840 if(index != type) {return false;} return v(ref_nested());
27850 ProtectedFootprintTimePattern ::= SEQUENCE {
27851 protectedFootprintTimePeriodicity INTEGER (1..320, ...),
27852 protectedFootprintStartTime INTEGER (1..20, ...),
27853 iE-Extensions ProtocolExtensionContainer { {ProtectedFootprintTimePattern-ExtIEs} } OPTIONAL,
27858 struct ProtectedFootprintTimePattern : asn::sequence<3, 0, true, 1>
27860 static constexpr const char* name() {return "ProtectedFootprintTimePattern";}
27861 using parent_t = asn::sequence<3, 0, true, 1>;
27862 struct protectedFootprintTimePeriodicity_t : asn::integer<>
27864 using constraint_t = asn::constraints<true,asn::span<1, 320>>;
27865 static constexpr const char* name() {return "protectedFootprintTimePeriodicity_t";}
27866 using parent_t = asn::integer<>;
27870 protectedFootprintTimePeriodicity_t& ref_protectedFootprintTimePeriodicity() {return protectedFootprintTimePeriodicity;}
27871 protectedFootprintTimePeriodicity_t const& ref_protectedFootprintTimePeriodicity() const {return protectedFootprintTimePeriodicity;}
27872 struct protectedFootprintStartTime_t : asn::integer<>
27874 using constraint_t = asn::constraints<true,asn::span<1, 20>>;
27875 static constexpr const char* name() {return "protectedFootprintStartTime_t";}
27876 using parent_t = asn::integer<>;
27880 protectedFootprintStartTime_t& ref_protectedFootprintStartTime() {return protectedFootprintStartTime;}
27881 protectedFootprintStartTime_t const& ref_protectedFootprintStartTime() const {return protectedFootprintStartTime;}
27882 struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedFootprintTimePattern_ExtIEs>
27884 static constexpr const char* name() {return "iE_Extensions_t";}
27885 using parent_t = ProtocolExtensionContainer<ProtectedFootprintTimePattern_ExtIEs>;
27886 static constexpr bool optional = true;
27889 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
27890 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
27891 template<typename V> void decode(V& v)
27893 v(protectedFootprintTimePeriodicity);
27894 v(protectedFootprintStartTime);
27898 template<typename V> void encode(V& v) const
27900 v(protectedFootprintTimePeriodicity);
27901 v(protectedFootprintStartTime);
27907 protectedFootprintTimePeriodicity.clear();
27908 protectedFootprintStartTime.clear();
27909 iE_Extensions.clear();
27913 protectedFootprintTimePeriodicity_t protectedFootprintTimePeriodicity;
27914 protectedFootprintStartTime_t protectedFootprintStartTime;
27915 iE_Extensions_t iE_Extensions;
27919 ProtectedResourceList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
27924 struct ProtectedResourceList_Item_ExtIEs
27926 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
27928 size_t get_index() const {return type;}
27929 bool is_unknown() const { return type == 1; }
27930 void clear() {type = 0;}
27931 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
27932 template<typename V> bool decode(V& v)
27935 if(!v(ref_nested())) return false;
27936 { type = 1; return true;}
27940 template<typename V> bool encode(V& v) const
27942 return v(ref_nested());
27946 template<typename V> bool decode(size_t index, V& v)
27951 case 1: type = 1; return v(ref_nested());
27952 ref_nested().clear();
27957 template<typename V> bool encode(size_t index, V& v) const
27959 if(index != type) {return false;} return v(ref_nested());
27966 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
27968 size_t get_index() const {return type;}
27969 bool is_unknown() const { return type == 1; }
27970 void clear() {type = 0;}
27971 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
27972 template<typename V> bool decode(V& v)
27975 if(!v(ref_nested())) return false;
27976 { type = 1; return true;}
27980 template<typename V> bool encode(V& v) const
27982 return v(ref_nested());
27986 template<typename V> bool decode(size_t index, V& v)
27991 case 1: type = 1; return v(ref_nested());
27992 ref_nested().clear();
27997 template<typename V> bool encode(size_t index, V& v) const
27999 if(index != type) {return false;} return v(ref_nested());
28006 struct Extension_t : asn::typefield<true>
28008 ~Extension_t() {clear();}
28009 size_t get_index() const {return type;}
28010 bool is_unknown() const { return type == 1; }
28013 type = 0; ref_nested().clear();
28015 template<typename V> static inline void enumerate(V& v)
28020 template<typename V> bool decode(size_t index, V& v)
28025 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28030 template<typename V> bool encode(size_t index, V& v) const
28032 if(index != type) return false;
28040 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28042 size_t get_index() const {return type;}
28043 bool is_unknown() const { return type == 1; }
28044 void clear() {type = 0;}
28045 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28046 template<typename V> bool decode(V& v)
28049 if(!v(ref_nested())) return false;
28050 { type = 1; return true;}
28054 template<typename V> bool encode(V& v) const
28056 return v(ref_nested());
28060 template<typename V> bool decode(size_t index, V& v)
28065 case 1: type = 1; return v(ref_nested());
28066 ref_nested().clear();
28071 template<typename V> bool encode(size_t index, V& v) const
28073 if(index != type) {return false;} return v(ref_nested());
28083 ProtectedResourceList-Item ::= SEQUENCE {
28084 resourceType ResourceType,
28085 intraPRBProtectedResourceFootprint BIT STRING (SIZE(84, ...)),
28086 protectedFootprintFrequencyPattern BIT STRING (SIZE(6..110, ...)),
28087 protectedFootprintTimePattern ProtectedFootprintTimePattern,
28088 iE-Extensions ProtocolExtensionContainer { {ProtectedResourceList-Item-ExtIEs} } OPTIONAL,
28093 struct ProtectedResourceList_Item : asn::sequence<5, 0, true, 1>
28095 static constexpr const char* name() {return "ProtectedResourceList-Item";}
28096 using parent_t = asn::sequence<5, 0, true, 1>;
28097 struct resourceType_t : ResourceType
28099 static constexpr const char* name() {return "resourceType_t";}
28100 using parent_t = ResourceType;
28103 resourceType_t& ref_resourceType() {return resourceType;}
28104 resourceType_t const& ref_resourceType() const {return resourceType;}
28105 struct intraPRBProtectedResourceFootprint_t : asn::bstring<>
28107 using constraint_t = asn::constraints<true,asn::one<84>>;
28108 static constexpr const char* name() {return "intraPRBProtectedResourceFootprint_t";}
28109 using parent_t = asn::bstring<>;
28113 intraPRBProtectedResourceFootprint_t& ref_intraPRBProtectedResourceFootprint() {return intraPRBProtectedResourceFootprint;}
28114 intraPRBProtectedResourceFootprint_t const& ref_intraPRBProtectedResourceFootprint() const {return intraPRBProtectedResourceFootprint;}
28115 struct protectedFootprintFrequencyPattern_t : asn::bstring<>
28117 using constraint_t = asn::constraints<true,asn::span<6, 110>>;
28118 static constexpr const char* name() {return "protectedFootprintFrequencyPattern_t";}
28119 using parent_t = asn::bstring<>;
28123 protectedFootprintFrequencyPattern_t& ref_protectedFootprintFrequencyPattern() {return protectedFootprintFrequencyPattern;}
28124 protectedFootprintFrequencyPattern_t const& ref_protectedFootprintFrequencyPattern() const {return protectedFootprintFrequencyPattern;}
28125 struct protectedFootprintTimePattern_t : ProtectedFootprintTimePattern
28127 static constexpr const char* name() {return "protectedFootprintTimePattern_t";}
28128 using parent_t = ProtectedFootprintTimePattern;
28131 protectedFootprintTimePattern_t& ref_protectedFootprintTimePattern() {return protectedFootprintTimePattern;}
28132 protectedFootprintTimePattern_t const& ref_protectedFootprintTimePattern() const {return protectedFootprintTimePattern;}
28133 struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedResourceList_Item_ExtIEs>
28135 static constexpr const char* name() {return "iE_Extensions_t";}
28136 using parent_t = ProtocolExtensionContainer<ProtectedResourceList_Item_ExtIEs>;
28137 static constexpr bool optional = true;
28140 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28141 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28142 template<typename V> void decode(V& v)
28145 v(intraPRBProtectedResourceFootprint);
28146 v(protectedFootprintFrequencyPattern);
28147 v(protectedFootprintTimePattern);
28151 template<typename V> void encode(V& v) const
28154 v(intraPRBProtectedResourceFootprint);
28155 v(protectedFootprintFrequencyPattern);
28156 v(protectedFootprintTimePattern);
28162 resourceType.clear();
28163 intraPRBProtectedResourceFootprint.clear();
28164 protectedFootprintFrequencyPattern.clear();
28165 protectedFootprintTimePattern.clear();
28166 iE_Extensions.clear();
28170 resourceType_t resourceType;
28171 intraPRBProtectedResourceFootprint_t intraPRBProtectedResourceFootprint;
28172 protectedFootprintFrequencyPattern_t protectedFootprintFrequencyPattern;
28173 protectedFootprintTimePattern_t protectedFootprintTimePattern;
28174 iE_Extensions_t iE_Extensions;
28178 ProtectedResourceList ::= SEQUENCE (SIZE(1.. maxnoofProtectedResourcePatterns)) OF ProtectedResourceList-Item
28181 struct ProtectedResourceList_elm : ProtectedResourceList_Item
28183 static constexpr const char* name() {return "ProtectedResourceList_elm";}
28184 using parent_t = ProtectedResourceList_Item;
28187 struct ProtectedResourceList : asn::sequenceof<ProtectedResourceList_elm>
28189 static constexpr const char* name() {return "ProtectedResourceList";}
28190 using parent_t = asn::sequenceof<ProtectedResourceList_elm>;
28191 using constraint_t = asn::constraints<false,asn::span<1, maxnoofProtectedResourcePatterns >>;
28195 ProtectedEUTRAResourceIndication-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28197 } -- Rapporteur: missing extension --
28200 struct ProtectedEUTRAResourceIndication_ExtIEs
28202 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28204 size_t get_index() const {return type;}
28205 bool is_unknown() const { return type == 1; }
28206 void clear() {type = 0;}
28207 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28208 template<typename V> bool decode(V& v)
28211 if(!v(ref_nested())) return false;
28212 { type = 1; return true;}
28216 template<typename V> bool encode(V& v) const
28218 return v(ref_nested());
28222 template<typename V> bool decode(size_t index, V& v)
28227 case 1: type = 1; return v(ref_nested());
28228 ref_nested().clear();
28233 template<typename V> bool encode(size_t index, V& v) const
28235 if(index != type) {return false;} return v(ref_nested());
28242 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28244 size_t get_index() const {return type;}
28245 bool is_unknown() const { return type == 1; }
28246 void clear() {type = 0;}
28247 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28248 template<typename V> bool decode(V& v)
28251 if(!v(ref_nested())) return false;
28252 { type = 1; return true;}
28256 template<typename V> bool encode(V& v) const
28258 return v(ref_nested());
28262 template<typename V> bool decode(size_t index, V& v)
28267 case 1: type = 1; return v(ref_nested());
28268 ref_nested().clear();
28273 template<typename V> bool encode(size_t index, V& v) const
28275 if(index != type) {return false;} return v(ref_nested());
28282 struct Extension_t : asn::typefield<true>
28284 ~Extension_t() {clear();}
28285 size_t get_index() const {return type;}
28286 bool is_unknown() const { return type == 1; }
28289 type = 0; ref_nested().clear();
28291 template<typename V> static inline void enumerate(V& v)
28296 template<typename V> bool decode(size_t index, V& v)
28301 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28306 template<typename V> bool encode(size_t index, V& v) const
28308 if(index != type) return false;
28316 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28318 size_t get_index() const {return type;}
28319 bool is_unknown() const { return type == 1; }
28320 void clear() {type = 0;}
28321 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28322 template<typename V> bool decode(V& v)
28325 if(!v(ref_nested())) return false;
28326 { type = 1; return true;}
28330 template<typename V> bool encode(V& v) const
28332 return v(ref_nested());
28336 template<typename V> bool decode(size_t index, V& v)
28341 case 1: type = 1; return v(ref_nested());
28342 ref_nested().clear();
28347 template<typename V> bool encode(size_t index, V& v) const
28349 if(index != type) {return false;} return v(ref_nested());
28359 ProtectedEUTRAResourceIndication::= SEQUENCE {
28360 activationSFN INTEGER (0..1023),
28361 protectedResourceList ProtectedResourceList,
28362 mBSFNControlRegionLength INTEGER (0..3) OPTIONAL,
28363 pDCCHRegionLength INTEGER (1..3) OPTIONAL,
28364 iE-Extensions ProtocolExtensionContainer { {ProtectedEUTRAResourceIndication-ExtIEs} } OPTIONAL,
28369 struct ProtectedEUTRAResourceIndication : asn::sequence<5, 0, true, 3>
28371 static constexpr const char* name() {return "ProtectedEUTRAResourceIndication";}
28372 using parent_t = asn::sequence<5, 0, true, 3>;
28373 struct activationSFN_t : asn::integer<>
28375 using constraint_t = asn::constraints<false,asn::span<0, 1023>>;
28376 static constexpr const char* name() {return "activationSFN_t";}
28377 using parent_t = asn::integer<>;
28381 activationSFN_t& ref_activationSFN() {return activationSFN;}
28382 activationSFN_t const& ref_activationSFN() const {return activationSFN;}
28383 struct protectedResourceList_t : ProtectedResourceList
28385 static constexpr const char* name() {return "protectedResourceList_t";}
28386 using parent_t = ProtectedResourceList;
28389 protectedResourceList_t& ref_protectedResourceList() {return protectedResourceList;}
28390 protectedResourceList_t const& ref_protectedResourceList() const {return protectedResourceList;}
28391 struct mBSFNControlRegionLength_t : asn::integer<>
28393 using constraint_t = asn::constraints<false,asn::span<0, 3>>;
28394 static constexpr const char* name() {return "mBSFNControlRegionLength_t";}
28395 using parent_t = asn::integer<>;
28396 static constexpr bool optional = true;
28400 mBSFNControlRegionLength_t& set_mBSFNControlRegionLength() { mBSFNControlRegionLength.setpresent(true); return mBSFNControlRegionLength;}
28401 mBSFNControlRegionLength_t const* get_mBSFNControlRegionLength() const {return mBSFNControlRegionLength.is_valid() ? &mBSFNControlRegionLength : nullptr;}
28402 struct pDCCHRegionLength_t : asn::integer<>
28404 using constraint_t = asn::constraints<false,asn::span<1, 3>>;
28405 static constexpr const char* name() {return "pDCCHRegionLength_t";}
28406 using parent_t = asn::integer<>;
28407 static constexpr bool optional = true;
28411 pDCCHRegionLength_t& set_pDCCHRegionLength() { pDCCHRegionLength.setpresent(true); return pDCCHRegionLength;}
28412 pDCCHRegionLength_t const* get_pDCCHRegionLength() const {return pDCCHRegionLength.is_valid() ? &pDCCHRegionLength : nullptr;}
28413 struct iE_Extensions_t : ProtocolExtensionContainer<ProtectedEUTRAResourceIndication_ExtIEs>
28415 static constexpr const char* name() {return "iE_Extensions_t";}
28416 using parent_t = ProtocolExtensionContainer<ProtectedEUTRAResourceIndication_ExtIEs>;
28417 static constexpr bool optional = true;
28420 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28421 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28422 template<typename V> void decode(V& v)
28425 v(protectedResourceList);
28426 v(mBSFNControlRegionLength);
28427 v(pDCCHRegionLength);
28431 template<typename V> void encode(V& v) const
28434 v(protectedResourceList);
28435 v(mBSFNControlRegionLength);
28436 v(pDCCHRegionLength);
28442 activationSFN.clear();
28443 protectedResourceList.clear();
28444 mBSFNControlRegionLength.clear();
28445 pDCCHRegionLength.clear();
28446 iE_Extensions.clear();
28450 activationSFN_t activationSFN;
28451 protectedResourceList_t protectedResourceList;
28452 mBSFNControlRegionLength_t mBSFNControlRegionLength;
28453 pDCCHRegionLength_t pDCCHRegionLength;
28454 iE_Extensions_t iE_Extensions;
28458 Reestablishment-Indication ::= ENUMERATED {
28464 struct Reestablishment_Indication : asn::enumerated<1, 0, true>
28466 static constexpr const char* name() {return "Reestablishment-Indication";}
28467 using parent_t = asn::enumerated<1, 0, true>;
28475 RLC-Status-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28480 struct RLC_Status_ExtIEs
28482 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28484 size_t get_index() const {return type;}
28485 bool is_unknown() const { return type == 1; }
28486 void clear() {type = 0;}
28487 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28488 template<typename V> bool decode(V& v)
28491 if(!v(ref_nested())) return false;
28492 { type = 1; return true;}
28496 template<typename V> bool encode(V& v) const
28498 return v(ref_nested());
28502 template<typename V> bool decode(size_t index, V& v)
28507 case 1: type = 1; return v(ref_nested());
28508 ref_nested().clear();
28513 template<typename V> bool encode(size_t index, V& v) const
28515 if(index != type) {return false;} return v(ref_nested());
28522 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28524 size_t get_index() const {return type;}
28525 bool is_unknown() const { return type == 1; }
28526 void clear() {type = 0;}
28527 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28528 template<typename V> bool decode(V& v)
28531 if(!v(ref_nested())) return false;
28532 { type = 1; return true;}
28536 template<typename V> bool encode(V& v) const
28538 return v(ref_nested());
28542 template<typename V> bool decode(size_t index, V& v)
28547 case 1: type = 1; return v(ref_nested());
28548 ref_nested().clear();
28553 template<typename V> bool encode(size_t index, V& v) const
28555 if(index != type) {return false;} return v(ref_nested());
28562 struct Extension_t : asn::typefield<true>
28564 ~Extension_t() {clear();}
28565 size_t get_index() const {return type;}
28566 bool is_unknown() const { return type == 1; }
28569 type = 0; ref_nested().clear();
28571 template<typename V> static inline void enumerate(V& v)
28576 template<typename V> bool decode(size_t index, V& v)
28581 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28586 template<typename V> bool encode(size_t index, V& v) const
28588 if(index != type) return false;
28596 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28598 size_t get_index() const {return type;}
28599 bool is_unknown() const { return type == 1; }
28600 void clear() {type = 0;}
28601 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28602 template<typename V> bool decode(V& v)
28605 if(!v(ref_nested())) return false;
28606 { type = 1; return true;}
28610 template<typename V> bool encode(V& v) const
28612 return v(ref_nested());
28616 template<typename V> bool decode(size_t index, V& v)
28621 case 1: type = 1; return v(ref_nested());
28622 ref_nested().clear();
28627 template<typename V> bool encode(size_t index, V& v) const
28629 if(index != type) {return false;} return v(ref_nested());
28639 RLC-Status ::= SEQUENCE {
28640 reestablishment-Indication Reestablishment-Indication,
28641 iE-Extensions ProtocolExtensionContainer { {RLC-Status-ExtIEs} } OPTIONAL,
28646 struct RLC_Status : asn::sequence<2, 0, true, 1>
28648 static constexpr const char* name() {return "RLC-Status";}
28649 using parent_t = asn::sequence<2, 0, true, 1>;
28650 struct reestablishment_Indication_t : Reestablishment_Indication
28652 static constexpr const char* name() {return "reestablishment_Indication_t";}
28653 using parent_t = Reestablishment_Indication;
28656 reestablishment_Indication_t& ref_reestablishment_Indication() {return reestablishment_Indication;}
28657 reestablishment_Indication_t const& ref_reestablishment_Indication() const {return reestablishment_Indication;}
28658 struct iE_Extensions_t : ProtocolExtensionContainer<RLC_Status_ExtIEs>
28660 static constexpr const char* name() {return "iE_Extensions_t";}
28661 using parent_t = ProtocolExtensionContainer<RLC_Status_ExtIEs>;
28662 static constexpr bool optional = true;
28665 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28666 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28667 template<typename V> void decode(V& v)
28669 v(reestablishment_Indication);
28673 template<typename V> void encode(V& v) const
28675 v(reestablishment_Indication);
28681 reestablishment_Indication.clear();
28682 iE_Extensions.clear();
28686 reestablishment_Indication_t reestablishment_Indication;
28687 iE_Extensions_t iE_Extensions;
28691 RLCMode ::= ENUMERATED {
28693 rlc-um-bidirectional,
28694 rlc-um-unidirectional-ul,
28695 rlc-um-unidirectional-dl,
28700 struct RLCMode : asn::enumerated<4, 0, true>
28702 static constexpr const char* name() {return "RLCMode";}
28703 using parent_t = asn::enumerated<4, 0, true>;
28706 ,rlc_um_bidirectional
28707 ,rlc_um_unidirectional_ul
28708 ,rlc_um_unidirectional_dl
28714 RRC-Config-Ind ::= ENUMERATED {
28721 struct RRC_Config_Ind : asn::enumerated<2, 0, true>
28723 static constexpr const char* name() {return "RRC-Config-Ind";}
28724 using parent_t = asn::enumerated<2, 0, true>;
28733 RRC-Context ::= OCTET STRING
28736 struct RRC_Context : asn::ostring<>
28738 static constexpr const char* name() {return "RRC-Context";}
28739 using parent_t = asn::ostring<>;
28744 RRCConnReestabIndicator ::= ENUMERATED {
28745 reconfigurationFailure, handoverFailure, otherFailure, ...
28749 struct RRCConnReestabIndicator : asn::enumerated<3, 0, true>
28751 static constexpr const char* name() {return "RRCConnReestabIndicator";}
28752 using parent_t = asn::enumerated<3, 0, true>;
28754 reconfigurationFailure
28762 RRCConnSetupIndicator::= ENUMERATED {
28768 struct RRCConnSetupIndicator : asn::enumerated<1, 0, true>
28770 static constexpr const char* name() {return "RRCConnSetupIndicator";}
28771 using parent_t = asn::enumerated<1, 0, true>;
28779 RRCContainer ::= OCTET STRING
28782 struct RRCContainer : asn::ostring<>
28784 static constexpr const char* name() {return "RRCContainer";}
28785 using parent_t = asn::ostring<>;
28790 RSRPMeasurementResult-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
28795 struct RSRPMeasurementResult_ExtIEs
28797 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
28799 size_t get_index() const {return type;}
28800 bool is_unknown() const { return type == 1; }
28801 void clear() {type = 0;}
28802 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
28803 template<typename V> bool decode(V& v)
28806 if(!v(ref_nested())) return false;
28807 { type = 1; return true;}
28811 template<typename V> bool encode(V& v) const
28813 return v(ref_nested());
28817 template<typename V> bool decode(size_t index, V& v)
28822 case 1: type = 1; return v(ref_nested());
28823 ref_nested().clear();
28828 template<typename V> bool encode(size_t index, V& v) const
28830 if(index != type) {return false;} return v(ref_nested());
28837 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
28839 size_t get_index() const {return type;}
28840 bool is_unknown() const { return type == 1; }
28841 void clear() {type = 0;}
28842 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
28843 template<typename V> bool decode(V& v)
28846 if(!v(ref_nested())) return false;
28847 { type = 1; return true;}
28851 template<typename V> bool encode(V& v) const
28853 return v(ref_nested());
28857 template<typename V> bool decode(size_t index, V& v)
28862 case 1: type = 1; return v(ref_nested());
28863 ref_nested().clear();
28868 template<typename V> bool encode(size_t index, V& v) const
28870 if(index != type) {return false;} return v(ref_nested());
28877 struct Extension_t : asn::typefield<true>
28879 ~Extension_t() {clear();}
28880 size_t get_index() const {return type;}
28881 bool is_unknown() const { return type == 1; }
28884 type = 0; ref_nested().clear();
28886 template<typename V> static inline void enumerate(V& v)
28891 template<typename V> bool decode(size_t index, V& v)
28896 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
28901 template<typename V> bool encode(size_t index, V& v) const
28903 if(index != type) return false;
28911 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
28913 size_t get_index() const {return type;}
28914 bool is_unknown() const { return type == 1; }
28915 void clear() {type = 0;}
28916 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
28917 template<typename V> bool decode(V& v)
28920 if(!v(ref_nested())) return false;
28921 { type = 1; return true;}
28925 template<typename V> bool encode(V& v) const
28927 return v(ref_nested());
28931 template<typename V> bool decode(size_t index, V& v)
28936 case 1: type = 1; return v(ref_nested());
28937 ref_nested().clear();
28942 template<typename V> bool encode(size_t index, V& v) const
28944 if(index != type) {return false;} return v(ref_nested());
28954 RSRPMeasurementResult ::= SEQUENCE (SIZE(1..maxCellReport)) OF
28957 rSRPMeasured INTEGER (0..97, ...),
28958 iE-Extensions ProtocolExtensionContainer { {RSRPMeasurementResult-ExtIEs} } OPTIONAL,
28963 struct RSRPMeasurementResult_elm : asn::sequence<3, 0, true, 1>
28965 static constexpr const char* name() {return "RSRPMeasurementResult_elm";}
28966 using parent_t = asn::sequence<3, 0, true, 1>;
28967 struct rSRPCellID_t : ECGI
28969 static constexpr const char* name() {return "rSRPCellID_t";}
28970 using parent_t = ECGI;
28973 rSRPCellID_t& ref_rSRPCellID() {return rSRPCellID;}
28974 rSRPCellID_t const& ref_rSRPCellID() const {return rSRPCellID;}
28975 struct rSRPMeasured_t : asn::integer<>
28977 using constraint_t = asn::constraints<true,asn::span<0, 97>>;
28978 static constexpr const char* name() {return "rSRPMeasured_t";}
28979 using parent_t = asn::integer<>;
28983 rSRPMeasured_t& ref_rSRPMeasured() {return rSRPMeasured;}
28984 rSRPMeasured_t const& ref_rSRPMeasured() const {return rSRPMeasured;}
28985 struct iE_Extensions_t : ProtocolExtensionContainer<RSRPMeasurementResult_ExtIEs>
28987 static constexpr const char* name() {return "iE_Extensions_t";}
28988 using parent_t = ProtocolExtensionContainer<RSRPMeasurementResult_ExtIEs>;
28989 static constexpr bool optional = true;
28992 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
28993 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
28994 template<typename V> void decode(V& v)
29001 template<typename V> void encode(V& v) const
29010 rSRPCellID.clear();
29011 rSRPMeasured.clear();
29012 iE_Extensions.clear();
29016 rSRPCellID_t rSRPCellID;
29017 rSRPMeasured_t rSRPMeasured;
29018 iE_Extensions_t iE_Extensions;
29021 struct RSRPMeasurementResult : asn::sequenceof<RSRPMeasurementResult_elm>
29023 static constexpr const char* name() {return "RSRPMeasurementResult";}
29024 using parent_t = asn::sequenceof<RSRPMeasurementResult_elm>;
29025 using constraint_t = asn::constraints<false,asn::span<1, maxCellReport >>;
29029 RSRPMRList-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
29030 { ID id-UEID CRITICALITY ignore EXTENSION UEID PRESENCE optional},
29035 struct RSRPMRList_ExtIEs
29037 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
29039 size_t get_index() const {return type;}
29040 bool is_unknown() const { return type == 2; }
29041 void clear() {type = 0;}
29042 void select_id_UEID() { set(id_UEID); type=1;}
29043 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
29044 template<typename V> bool decode(V& v)
29047 if(!v(ref_nested())) return false;
29048 if(equal(id_UEID)) { type = 1; return true; }
29049 else { type = 2; return true;}
29053 template<typename V> bool encode(V& v) const
29055 return v(ref_nested());
29059 template<typename V> bool decode(size_t index, V& v)
29064 case 1: type = 1; if(v(ref_nested())) { return equal(id_UEID);} return false;
29065 case 2: type = 2; return v(ref_nested());
29066 ref_nested().clear();
29071 template<typename V> bool encode(size_t index, V& v) const
29073 if(index != type) {return false;} return v(ref_nested());
29080 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29082 size_t get_index() const {return type;}
29083 bool is_unknown() const { return type == 2; }
29084 void clear() {type = 0;}
29085 void select_id_UEID() { set(ignore); type=1;}
29086 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
29087 template<typename V> bool decode(V& v)
29090 if(!v(ref_nested())) return false;
29091 if(equal(ignore)) { type = 1; return true; }
29092 else { type = 2; return true;}
29096 template<typename V> bool encode(V& v) const
29098 return v(ref_nested());
29102 template<typename V> bool decode(size_t index, V& v)
29107 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
29108 case 2: type = 2; return v(ref_nested());
29109 ref_nested().clear();
29114 template<typename V> bool encode(size_t index, V& v) const
29116 if(index != type) {return false;} return v(ref_nested());
29123 struct Extension_t : asn::typefield<true>
29125 ~Extension_t() {clear();}
29126 size_t get_index() const {return type;}
29127 UEID& select_id_UEID() { return set<UEID>(1); }
29128 UEID const* get_id_UEID() const { return get<UEID>(1); }
29129 bool is_unknown() const { return type == 2; }
29134 case 1: var.destroy<UEID>(); break;
29136 type = 0; ref_nested().clear();
29138 template<typename V> static inline void enumerate(V& v)
29140 v.template operator()<UEID>(1);
29144 template<typename V> bool decode(size_t index, V& v)
29149 case 1: v(select_id_UEID()); return true;
29150 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
29155 template<typename V> bool encode(size_t index, V& v) const
29157 if(index != type) return false;
29160 case 1: v(var.as<UEID>()); return true;
29166 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
29167 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
29170 char dummy1[sizeof(UEID)];
29173 asn::variant<sizeof(union_type)> var;
29177 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
29179 size_t get_index() const {return type;}
29180 bool is_unknown() const { return type == 2; }
29181 void clear() {type = 0;}
29182 void select_id_UEID() { set(optional); type=1;}
29183 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
29184 template<typename V> bool decode(V& v)
29187 if(!v(ref_nested())) return false;
29188 if(equal(optional)) { type = 1; return true; }
29189 else { type = 2; return true;}
29193 template<typename V> bool encode(V& v) const
29195 return v(ref_nested());
29199 template<typename V> bool decode(size_t index, V& v)
29204 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
29205 case 2: type = 2; return v(ref_nested());
29206 ref_nested().clear();
29211 template<typename V> bool encode(size_t index, V& v) const
29213 if(index != type) {return false;} return v(ref_nested());
29223 RSRPMRList ::= SEQUENCE (SIZE(1..maxUEReport)) OF
29225 rSRPMeasurementResult RSRPMeasurementResult,
29226 iE-Extensions ProtocolExtensionContainer { {RSRPMRList-ExtIEs} } OPTIONAL,
29231 struct RSRPMRList_elm : asn::sequence<2, 0, true, 1>
29233 static constexpr const char* name() {return "RSRPMRList_elm";}
29234 using parent_t = asn::sequence<2, 0, true, 1>;
29235 struct rSRPMeasurementResult_t : RSRPMeasurementResult
29237 static constexpr const char* name() {return "rSRPMeasurementResult_t";}
29238 using parent_t = RSRPMeasurementResult;
29241 rSRPMeasurementResult_t& ref_rSRPMeasurementResult() {return rSRPMeasurementResult;}
29242 rSRPMeasurementResult_t const& ref_rSRPMeasurementResult() const {return rSRPMeasurementResult;}
29243 struct iE_Extensions_t : ProtocolExtensionContainer<RSRPMRList_ExtIEs>
29245 static constexpr const char* name() {return "iE_Extensions_t";}
29246 using parent_t = ProtocolExtensionContainer<RSRPMRList_ExtIEs>;
29247 static constexpr bool optional = true;
29250 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
29251 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
29252 template<typename V> void decode(V& v)
29254 v(rSRPMeasurementResult);
29258 template<typename V> void encode(V& v) const
29260 v(rSRPMeasurementResult);
29266 rSRPMeasurementResult.clear();
29267 iE_Extensions.clear();
29271 rSRPMeasurementResult_t rSRPMeasurementResult;
29272 iE_Extensions_t iE_Extensions;
29275 struct RSRPMRList : asn::sequenceof<RSRPMRList_elm>
29277 static constexpr const char* name() {return "RSRPMRList";}
29278 using parent_t = asn::sequenceof<RSRPMRList_elm>;
29279 using constraint_t = asn::constraints<false,asn::span<1, maxUEReport >>;
29283 UL-GBR-PRB-usage::= INTEGER (0..100)
29286 struct UL_GBR_PRB_usage : asn::integer<>
29288 using constraint_t = asn::constraints<false,asn::span<0, 100>>;
29289 static constexpr const char* name() {return "UL-GBR-PRB-usage";}
29290 using parent_t = asn::integer<>;
29295 UL-non-GBR-PRB-usage::= INTEGER (0..100)
29298 struct UL_non_GBR_PRB_usage : asn::integer<>
29300 using constraint_t = asn::constraints<false,asn::span<0, 100>>;
29301 static constexpr const char* name() {return "UL-non-GBR-PRB-usage";}
29302 using parent_t = asn::integer<>;
29307 UL-Total-PRB-usage::= INTEGER (0..100)
29310 struct UL_Total_PRB_usage : asn::integer<>
29312 using constraint_t = asn::constraints<false,asn::span<0, 100>>;
29313 static constexpr const char* name() {return "UL-Total-PRB-usage";}
29314 using parent_t = asn::integer<>;
29319 UL-scheduling-PDCCH-CCE-usage::= INTEGER (0..100)
29322 struct UL_scheduling_PDCCH_CCE_usage : asn::integer<>
29324 using constraint_t = asn::constraints<false,asn::span<0, 100>>;
29325 static constexpr const char* name() {return "UL-scheduling-PDCCH-CCE-usage";}
29326 using parent_t = asn::integer<>;
29331 RadioResourceStatus-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
29332 {ID id-DL-scheduling-PDCCH-CCE-usage CRITICALITY ignore EXTENSION DL-scheduling-PDCCH-CCE-usage PRESENCE optional}|
29334 {ID id-UL-scheduling-PDCCH-CCE-usage CRITICALITY ignore EXTENSION UL-scheduling-PDCCH-CCE-usage PRESENCE optional},
29339 struct RadioResourceStatus_ExtIEs
29341 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
29343 size_t get_index() const {return type;}
29344 bool is_unknown() const { return type == 3; }
29345 void clear() {type = 0;}
29346 void select_id_DL_scheduling_PDCCH_CCE_usage() { set(id_DL_scheduling_PDCCH_CCE_usage); type=1;}
29347 void select_id_UL_scheduling_PDCCH_CCE_usage() { set(id_UL_scheduling_PDCCH_CCE_usage); type=2;}
29348 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
29349 template<typename V> bool decode(V& v)
29352 if(!v(ref_nested())) return false;
29353 if(equal(id_DL_scheduling_PDCCH_CCE_usage)) { type = 1; return true; }
29354 else if(equal(id_UL_scheduling_PDCCH_CCE_usage)) { type = 2; return true; }
29355 else { type = 3; return true;}
29359 template<typename V> bool encode(V& v) const
29361 return v(ref_nested());
29365 template<typename V> bool decode(size_t index, V& v)
29370 case 1: type = 1; if(v(ref_nested())) { return equal(id_DL_scheduling_PDCCH_CCE_usage);} return false;
29371 case 2: type = 2; if(v(ref_nested())) { return equal(id_UL_scheduling_PDCCH_CCE_usage);} return false;
29372 case 3: type = 3; return v(ref_nested());
29373 ref_nested().clear();
29378 template<typename V> bool encode(size_t index, V& v) const
29380 if(index != type) {return false;} return v(ref_nested());
29387 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29389 size_t get_index() const {return type;}
29390 bool is_unknown() const { return type == 3; }
29391 void clear() {type = 0;}
29392 void select_id_DL_scheduling_PDCCH_CCE_usage() { set(ignore); type=1;}
29393 void select_id_UL_scheduling_PDCCH_CCE_usage() { set(ignore); type=2;}
29394 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
29395 template<typename V> bool decode(V& v)
29398 if(!v(ref_nested())) return false;
29399 if(equal(ignore)) { type = 1; return true; }
29400 else if(equal(ignore)) { type = 2; return true; }
29401 else { type = 3; return true;}
29405 template<typename V> bool encode(V& v) const
29407 return v(ref_nested());
29411 template<typename V> bool decode(size_t index, V& v)
29416 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
29417 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
29418 case 3: type = 3; return v(ref_nested());
29419 ref_nested().clear();
29424 template<typename V> bool encode(size_t index, V& v) const
29426 if(index != type) {return false;} return v(ref_nested());
29433 struct Extension_t : asn::typefield<true>
29435 ~Extension_t() {clear();}
29436 size_t get_index() const {return type;}
29437 DL_scheduling_PDCCH_CCE_usage& select_id_DL_scheduling_PDCCH_CCE_usage() { return set<DL_scheduling_PDCCH_CCE_usage>(1); }
29438 DL_scheduling_PDCCH_CCE_usage const* get_id_DL_scheduling_PDCCH_CCE_usage() const { return get<DL_scheduling_PDCCH_CCE_usage>(1); }
29439 UL_scheduling_PDCCH_CCE_usage& select_id_UL_scheduling_PDCCH_CCE_usage() { return set<UL_scheduling_PDCCH_CCE_usage>(2); }
29440 UL_scheduling_PDCCH_CCE_usage const* get_id_UL_scheduling_PDCCH_CCE_usage() const { return get<UL_scheduling_PDCCH_CCE_usage>(2); }
29441 bool is_unknown() const { return type == 3; }
29446 case 1: var.destroy<DL_scheduling_PDCCH_CCE_usage>(); break;
29447 case 2: var.destroy<UL_scheduling_PDCCH_CCE_usage>(); break;
29449 type = 0; ref_nested().clear();
29451 template<typename V> static inline void enumerate(V& v)
29453 v.template operator()<DL_scheduling_PDCCH_CCE_usage>(1);
29454 v.template operator()<UL_scheduling_PDCCH_CCE_usage>(2);
29458 template<typename V> bool decode(size_t index, V& v)
29463 case 1: v(select_id_DL_scheduling_PDCCH_CCE_usage()); return true;
29464 case 2: v(select_id_UL_scheduling_PDCCH_CCE_usage()); return true;
29465 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
29470 template<typename V> bool encode(size_t index, V& v) const
29472 if(index != type) return false;
29475 case 1: v(var.as<DL_scheduling_PDCCH_CCE_usage>()); return true;
29476 case 2: v(var.as<UL_scheduling_PDCCH_CCE_usage>()); return true;
29482 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
29483 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
29486 char dummy1[sizeof(DL_scheduling_PDCCH_CCE_usage)];
29487 char dummy2[sizeof(UL_scheduling_PDCCH_CCE_usage)];
29490 asn::variant<sizeof(union_type)> var;
29494 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
29496 size_t get_index() const {return type;}
29497 bool is_unknown() const { return type == 3; }
29498 void clear() {type = 0;}
29499 void select_id_DL_scheduling_PDCCH_CCE_usage() { set(optional); type=1;}
29500 void select_id_UL_scheduling_PDCCH_CCE_usage() { set(optional); type=2;}
29501 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
29502 template<typename V> bool decode(V& v)
29505 if(!v(ref_nested())) return false;
29506 if(equal(optional)) { type = 1; return true; }
29507 else if(equal(optional)) { type = 2; return true; }
29508 else { type = 3; return true;}
29512 template<typename V> bool encode(V& v) const
29514 return v(ref_nested());
29518 template<typename V> bool decode(size_t index, V& v)
29523 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
29524 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
29525 case 3: type = 3; return v(ref_nested());
29526 ref_nested().clear();
29531 template<typename V> bool encode(size_t index, V& v) const
29533 if(index != type) {return false;} return v(ref_nested());
29543 RadioResourceStatus ::= SEQUENCE {
29544 dL-GBR-PRB-usage DL-GBR-PRB-usage,
29545 uL-GBR-PRB-usage UL-GBR-PRB-usage,
29546 dL-non-GBR-PRB-usage DL-non-GBR-PRB-usage,
29547 uL-non-GBR-PRB-usage UL-non-GBR-PRB-usage,
29548 dL-Total-PRB-usage DL-Total-PRB-usage,
29549 uL-Total-PRB-usage UL-Total-PRB-usage,
29550 iE-Extensions ProtocolExtensionContainer { {RadioResourceStatus-ExtIEs} } OPTIONAL,
29555 struct RadioResourceStatus : asn::sequence<7, 0, true, 1>
29557 static constexpr const char* name() {return "RadioResourceStatus";}
29558 using parent_t = asn::sequence<7, 0, true, 1>;
29559 struct dL_GBR_PRB_usage_t : DL_GBR_PRB_usage
29561 static constexpr const char* name() {return "dL_GBR_PRB_usage_t";}
29562 using parent_t = DL_GBR_PRB_usage;
29565 dL_GBR_PRB_usage_t& ref_dL_GBR_PRB_usage() {return dL_GBR_PRB_usage;}
29566 dL_GBR_PRB_usage_t const& ref_dL_GBR_PRB_usage() const {return dL_GBR_PRB_usage;}
29567 struct uL_GBR_PRB_usage_t : UL_GBR_PRB_usage
29569 static constexpr const char* name() {return "uL_GBR_PRB_usage_t";}
29570 using parent_t = UL_GBR_PRB_usage;
29573 uL_GBR_PRB_usage_t& ref_uL_GBR_PRB_usage() {return uL_GBR_PRB_usage;}
29574 uL_GBR_PRB_usage_t const& ref_uL_GBR_PRB_usage() const {return uL_GBR_PRB_usage;}
29575 struct dL_non_GBR_PRB_usage_t : DL_non_GBR_PRB_usage
29577 static constexpr const char* name() {return "dL_non_GBR_PRB_usage_t";}
29578 using parent_t = DL_non_GBR_PRB_usage;
29581 dL_non_GBR_PRB_usage_t& ref_dL_non_GBR_PRB_usage() {return dL_non_GBR_PRB_usage;}
29582 dL_non_GBR_PRB_usage_t const& ref_dL_non_GBR_PRB_usage() const {return dL_non_GBR_PRB_usage;}
29583 struct uL_non_GBR_PRB_usage_t : UL_non_GBR_PRB_usage
29585 static constexpr const char* name() {return "uL_non_GBR_PRB_usage_t";}
29586 using parent_t = UL_non_GBR_PRB_usage;
29589 uL_non_GBR_PRB_usage_t& ref_uL_non_GBR_PRB_usage() {return uL_non_GBR_PRB_usage;}
29590 uL_non_GBR_PRB_usage_t const& ref_uL_non_GBR_PRB_usage() const {return uL_non_GBR_PRB_usage;}
29591 struct dL_Total_PRB_usage_t : DL_Total_PRB_usage
29593 static constexpr const char* name() {return "dL_Total_PRB_usage_t";}
29594 using parent_t = DL_Total_PRB_usage;
29597 dL_Total_PRB_usage_t& ref_dL_Total_PRB_usage() {return dL_Total_PRB_usage;}
29598 dL_Total_PRB_usage_t const& ref_dL_Total_PRB_usage() const {return dL_Total_PRB_usage;}
29599 struct uL_Total_PRB_usage_t : UL_Total_PRB_usage
29601 static constexpr const char* name() {return "uL_Total_PRB_usage_t";}
29602 using parent_t = UL_Total_PRB_usage;
29605 uL_Total_PRB_usage_t& ref_uL_Total_PRB_usage() {return uL_Total_PRB_usage;}
29606 uL_Total_PRB_usage_t const& ref_uL_Total_PRB_usage() const {return uL_Total_PRB_usage;}
29607 struct iE_Extensions_t : ProtocolExtensionContainer<RadioResourceStatus_ExtIEs>
29609 static constexpr const char* name() {return "iE_Extensions_t";}
29610 using parent_t = ProtocolExtensionContainer<RadioResourceStatus_ExtIEs>;
29611 static constexpr bool optional = true;
29614 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
29615 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
29616 template<typename V> void decode(V& v)
29618 v(dL_GBR_PRB_usage);
29619 v(uL_GBR_PRB_usage);
29620 v(dL_non_GBR_PRB_usage);
29621 v(uL_non_GBR_PRB_usage);
29622 v(dL_Total_PRB_usage);
29623 v(uL_Total_PRB_usage);
29627 template<typename V> void encode(V& v) const
29629 v(dL_GBR_PRB_usage);
29630 v(uL_GBR_PRB_usage);
29631 v(dL_non_GBR_PRB_usage);
29632 v(uL_non_GBR_PRB_usage);
29633 v(dL_Total_PRB_usage);
29634 v(uL_Total_PRB_usage);
29640 dL_GBR_PRB_usage.clear();
29641 uL_GBR_PRB_usage.clear();
29642 dL_non_GBR_PRB_usage.clear();
29643 uL_non_GBR_PRB_usage.clear();
29644 dL_Total_PRB_usage.clear();
29645 uL_Total_PRB_usage.clear();
29646 iE_Extensions.clear();
29650 dL_GBR_PRB_usage_t dL_GBR_PRB_usage;
29651 uL_GBR_PRB_usage_t uL_GBR_PRB_usage;
29652 dL_non_GBR_PRB_usage_t dL_non_GBR_PRB_usage;
29653 uL_non_GBR_PRB_usage_t uL_non_GBR_PRB_usage;
29654 dL_Total_PRB_usage_t dL_Total_PRB_usage;
29655 uL_Total_PRB_usage_t uL_Total_PRB_usage;
29656 iE_Extensions_t iE_Extensions;
29660 ReceiveStatusOfULPDCPSDUsExtended ::= BIT STRING (SIZE(1..16384))
29663 struct ReceiveStatusOfULPDCPSDUsExtended : asn::bstring<>
29665 using constraint_t = asn::constraints<false,asn::span<1, 16384>>;
29666 static constexpr const char* name() {return "ReceiveStatusOfULPDCPSDUsExtended";}
29667 using parent_t = asn::bstring<>;
29672 ReceiveStatusOfULPDCPSDUsPDCP-SNlength18 ::= BIT STRING (SIZE(1..131072))
29675 struct ReceiveStatusOfULPDCPSDUsPDCP_SNlength18 : asn::bstring<>
29677 using constraint_t = asn::constraints<false,asn::span<1, 131072>>;
29678 static constexpr const char* name() {return "ReceiveStatusOfULPDCPSDUsPDCP-SNlength18";}
29679 using parent_t = asn::bstring<>;
29684 ReceiveStatusofULPDCPSDUs ::= BIT STRING (SIZE(4096))
29687 struct ReceiveStatusofULPDCPSDUs : asn::bstring<>
29689 using constraint_t = asn::constraints<false,asn::one<4096>>;
29690 static constexpr const char* name() {return "ReceiveStatusofULPDCPSDUs";}
29691 using parent_t = asn::bstring<>;
29696 Registration-Request ::= ENUMERATED {
29705 struct Registration_Request : asn::enumerated<4, 2, true>
29707 static constexpr const char* name() {return "Registration-Request";}
29708 using parent_t = asn::enumerated<4, 2, true>;
29719 RelativeNarrowbandTxPower-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
29720 { ID id-enhancedRNTP CRITICALITY ignore EXTENSION EnhancedRNTP PRESENCE optional },
29725 struct RelativeNarrowbandTxPower_ExtIEs
29727 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
29729 size_t get_index() const {return type;}
29730 bool is_unknown() const { return type == 2; }
29731 void clear() {type = 0;}
29732 void select_id_enhancedRNTP() { set(id_enhancedRNTP); type=1;}
29733 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
29734 template<typename V> bool decode(V& v)
29737 if(!v(ref_nested())) return false;
29738 if(equal(id_enhancedRNTP)) { type = 1; return true; }
29739 else { type = 2; return true;}
29743 template<typename V> bool encode(V& v) const
29745 return v(ref_nested());
29749 template<typename V> bool decode(size_t index, V& v)
29754 case 1: type = 1; if(v(ref_nested())) { return equal(id_enhancedRNTP);} return false;
29755 case 2: type = 2; return v(ref_nested());
29756 ref_nested().clear();
29761 template<typename V> bool encode(size_t index, V& v) const
29763 if(index != type) {return false;} return v(ref_nested());
29770 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
29772 size_t get_index() const {return type;}
29773 bool is_unknown() const { return type == 2; }
29774 void clear() {type = 0;}
29775 void select_id_enhancedRNTP() { set(ignore); type=1;}
29776 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
29777 template<typename V> bool decode(V& v)
29780 if(!v(ref_nested())) return false;
29781 if(equal(ignore)) { type = 1; return true; }
29782 else { type = 2; return true;}
29786 template<typename V> bool encode(V& v) const
29788 return v(ref_nested());
29792 template<typename V> bool decode(size_t index, V& v)
29797 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
29798 case 2: type = 2; return v(ref_nested());
29799 ref_nested().clear();
29804 template<typename V> bool encode(size_t index, V& v) const
29806 if(index != type) {return false;} return v(ref_nested());
29813 struct Extension_t : asn::typefield<true>
29815 ~Extension_t() {clear();}
29816 size_t get_index() const {return type;}
29817 EnhancedRNTP& select_id_enhancedRNTP() { return set<EnhancedRNTP>(1); }
29818 EnhancedRNTP const* get_id_enhancedRNTP() const { return get<EnhancedRNTP>(1); }
29819 bool is_unknown() const { return type == 2; }
29824 case 1: var.destroy<EnhancedRNTP>(); break;
29826 type = 0; ref_nested().clear();
29828 template<typename V> static inline void enumerate(V& v)
29830 v.template operator()<EnhancedRNTP>(1);
29834 template<typename V> bool decode(size_t index, V& v)
29839 case 1: v(select_id_enhancedRNTP()); return true;
29840 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
29845 template<typename V> bool encode(size_t index, V& v) const
29847 if(index != type) return false;
29850 case 1: v(var.as<EnhancedRNTP>()); return true;
29856 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
29857 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
29860 char dummy1[sizeof(EnhancedRNTP)];
29863 asn::variant<sizeof(union_type)> var;
29867 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
29869 size_t get_index() const {return type;}
29870 bool is_unknown() const { return type == 2; }
29871 void clear() {type = 0;}
29872 void select_id_enhancedRNTP() { set(optional); type=1;}
29873 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
29874 template<typename V> bool decode(V& v)
29877 if(!v(ref_nested())) return false;
29878 if(equal(optional)) { type = 1; return true; }
29879 else { type = 2; return true;}
29883 template<typename V> bool encode(V& v) const
29885 return v(ref_nested());
29889 template<typename V> bool decode(size_t index, V& v)
29894 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
29895 case 2: type = 2; return v(ref_nested());
29896 ref_nested().clear();
29901 template<typename V> bool encode(size_t index, V& v) const
29903 if(index != type) {return false;} return v(ref_nested());
29913 RelativeNarrowbandTxPower ::= SEQUENCE {
29915 rNTP-PerPRB BIT STRING (SIZE(6..110, ...)),
29916 rNTP-Threshold RNTP-Threshold,
29917 numberOfCellSpecificAntennaPorts ENUMERATED {one, two, four, ...},
29918 p-B INTEGER (0..3,...),
29919 pDCCH-InterferenceImpact INTEGER (0..4,...),
29920 iE-Extensions ProtocolExtensionContainer { {RelativeNarrowbandTxPower-ExtIEs} } OPTIONAL,
29925 struct RelativeNarrowbandTxPower : asn::sequence<6, 0, true, 1>
29927 static constexpr const char* name() {return "RelativeNarrowbandTxPower";}
29928 using parent_t = asn::sequence<6, 0, true, 1>;
29929 struct rNTP_PerPRB_t : asn::bstring<>
29931 using constraint_t = asn::constraints<true,asn::span<6, 110>>;
29932 static constexpr const char* name() {return "rNTP_PerPRB_t";}
29933 using parent_t = asn::bstring<>;
29937 rNTP_PerPRB_t& ref_rNTP_PerPRB() {return rNTP_PerPRB;}
29938 rNTP_PerPRB_t const& ref_rNTP_PerPRB() const {return rNTP_PerPRB;}
29939 struct rNTP_Threshold_t : RNTP_Threshold
29941 static constexpr const char* name() {return "rNTP_Threshold_t";}
29942 using parent_t = RNTP_Threshold;
29945 rNTP_Threshold_t& ref_rNTP_Threshold() {return rNTP_Threshold;}
29946 rNTP_Threshold_t const& ref_rNTP_Threshold() const {return rNTP_Threshold;}
29947 struct numberOfCellSpecificAntennaPorts_t : asn::enumerated<3, 0, true>
29949 static constexpr const char* name() {return "numberOfCellSpecificAntennaPorts_t";}
29950 using parent_t = asn::enumerated<3, 0, true>;
29959 numberOfCellSpecificAntennaPorts_t& ref_numberOfCellSpecificAntennaPorts() {return numberOfCellSpecificAntennaPorts;}
29960 numberOfCellSpecificAntennaPorts_t const& ref_numberOfCellSpecificAntennaPorts() const {return numberOfCellSpecificAntennaPorts;}
29961 struct p_B_t : asn::integer<>
29963 using constraint_t = asn::constraints<true,asn::span<0, 3>>;
29964 static constexpr const char* name() {return "p_B_t";}
29965 using parent_t = asn::integer<>;
29969 p_B_t& ref_p_B() {return p_B;}
29970 p_B_t const& ref_p_B() const {return p_B;}
29971 struct pDCCH_InterferenceImpact_t : asn::integer<>
29973 using constraint_t = asn::constraints<true,asn::span<0, 4>>;
29974 static constexpr const char* name() {return "pDCCH_InterferenceImpact_t";}
29975 using parent_t = asn::integer<>;
29979 pDCCH_InterferenceImpact_t& ref_pDCCH_InterferenceImpact() {return pDCCH_InterferenceImpact;}
29980 pDCCH_InterferenceImpact_t const& ref_pDCCH_InterferenceImpact() const {return pDCCH_InterferenceImpact;}
29981 struct iE_Extensions_t : ProtocolExtensionContainer<RelativeNarrowbandTxPower_ExtIEs>
29983 static constexpr const char* name() {return "iE_Extensions_t";}
29984 using parent_t = ProtocolExtensionContainer<RelativeNarrowbandTxPower_ExtIEs>;
29985 static constexpr bool optional = true;
29988 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
29989 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
29990 template<typename V> void decode(V& v)
29994 v(numberOfCellSpecificAntennaPorts);
29996 v(pDCCH_InterferenceImpact);
30000 template<typename V> void encode(V& v) const
30004 v(numberOfCellSpecificAntennaPorts);
30006 v(pDCCH_InterferenceImpact);
30012 rNTP_PerPRB.clear();
30013 rNTP_Threshold.clear();
30014 numberOfCellSpecificAntennaPorts.clear();
30016 pDCCH_InterferenceImpact.clear();
30017 iE_Extensions.clear();
30021 rNTP_PerPRB_t rNTP_PerPRB;
30022 rNTP_Threshold_t rNTP_Threshold;
30023 numberOfCellSpecificAntennaPorts_t numberOfCellSpecificAntennaPorts;
30025 pDCCH_InterferenceImpact_t pDCCH_InterferenceImpact;
30026 iE_Extensions_t iE_Extensions;
30030 ReportCharacteristics ::= BIT STRING (SIZE (32))
30033 struct ReportCharacteristics : asn::bstring<>
30035 using constraint_t = asn::constraints<false,asn::one<32>>;
30036 static constexpr const char* name() {return "ReportCharacteristics";}
30037 using parent_t = asn::bstring<>;
30042 ReportingPeriodicityCSIR ::= ENUMERATED {
30052 struct ReportingPeriodicityCSIR : asn::enumerated<5, 0, true>
30054 static constexpr const char* name() {return "ReportingPeriodicityCSIR";}
30055 using parent_t = asn::enumerated<5, 0, true>;
30067 ReportingPeriodicityRSRPMR ::= ENUMERATED {
30070 four-hundred-80-ms,
30076 struct ReportingPeriodicityRSRPMR : asn::enumerated<4, 0, true>
30078 static constexpr const char* name() {return "ReportingPeriodicityRSRPMR";}
30079 using parent_t = asn::enumerated<4, 0, true>;
30083 ,four_hundred_80_ms
30090 ResumeID ::= CHOICE {
30091 non-truncated BIT STRING(SIZE(40)),
30092 truncated BIT STRING(SIZE(24)),
30097 struct ResumeID : asn::choice<2, 0, true>
30099 static constexpr const char* name() {return "ResumeID";}
30100 using parent_t = asn::choice<2, 0, true>;
30101 index_type get_index() const {return index;}
30102 bool is_unknown() const {return index == 3;}
30103 void set_unknown() { set_index(3); }
30104 ~ResumeID() {clear();}
30105 struct non_truncated_t : asn::bstring<>
30107 using constraint_t = asn::constraints<false,asn::one<40>>;
30108 static constexpr const char* name() {return "non_truncated_t";}
30109 using parent_t = asn::bstring<>;
30113 struct truncated_t : asn::bstring<>
30115 using constraint_t = asn::constraints<false,asn::one<24>>;
30116 static constexpr const char* name() {return "truncated_t";}
30117 using parent_t = asn::bstring<>;
30123 switch(get_index())
30125 case 1: var.destroy<non_truncated_t>(); break;
30126 case 2: var.destroy<truncated_t>(); break;
30131 template<typename V> bool decode(size_t idx, V& v)
30136 case 1: set_index(1); return v(var.build<non_truncated_t>());
30137 case 2: set_index(2); return v(var.build<truncated_t>());
30142 template<typename V> bool encode(V& v) const
30144 switch(get_index())
30146 case 1: return v(var.as<non_truncated_t>());
30147 case 2: return v(var.as<truncated_t>());
30151 template<typename V> static inline void enumerate(V& v)
30153 v.template operator()<non_truncated_t>(1);
30154 v.template operator()<truncated_t>(2);
30157 non_truncated_t& select_non_truncated() { if(get_index() != 1) { clear(); set_index(1); return var.build<non_truncated_t>();} return var.as<non_truncated_t>();}
30158 non_truncated_t const* get_non_truncated() const { if(get_index() == 1) { return &var.as<non_truncated_t>();} return nullptr; }
30159 truncated_t& select_truncated() { if(get_index() != 2) { clear(); set_index(2); return var.build<truncated_t>();} return var.as<truncated_t>();}
30160 truncated_t const* get_truncated() const { if(get_index() == 2) { return &var.as<truncated_t>();} return nullptr; }
30162 void set_index(index_type i) {index = i; base::set();}
30165 char dummy1[sizeof(non_truncated_t)];
30166 char dummy2[sizeof(truncated_t)];
30169 asn::variant<sizeof(union_type)> var;
30170 index_type index {0};
30173 S1TNLLoadIndicator-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
30178 struct S1TNLLoadIndicator_ExtIEs
30180 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
30182 size_t get_index() const {return type;}
30183 bool is_unknown() const { return type == 1; }
30184 void clear() {type = 0;}
30185 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
30186 template<typename V> bool decode(V& v)
30189 if(!v(ref_nested())) return false;
30190 { type = 1; return true;}
30194 template<typename V> bool encode(V& v) const
30196 return v(ref_nested());
30200 template<typename V> bool decode(size_t index, V& v)
30205 case 1: type = 1; return v(ref_nested());
30206 ref_nested().clear();
30211 template<typename V> bool encode(size_t index, V& v) const
30213 if(index != type) {return false;} return v(ref_nested());
30220 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
30222 size_t get_index() const {return type;}
30223 bool is_unknown() const { return type == 1; }
30224 void clear() {type = 0;}
30225 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
30226 template<typename V> bool decode(V& v)
30229 if(!v(ref_nested())) return false;
30230 { type = 1; return true;}
30234 template<typename V> bool encode(V& v) const
30236 return v(ref_nested());
30240 template<typename V> bool decode(size_t index, V& v)
30245 case 1: type = 1; return v(ref_nested());
30246 ref_nested().clear();
30251 template<typename V> bool encode(size_t index, V& v) const
30253 if(index != type) {return false;} return v(ref_nested());
30260 struct Extension_t : asn::typefield<true>
30262 ~Extension_t() {clear();}
30263 size_t get_index() const {return type;}
30264 bool is_unknown() const { return type == 1; }
30267 type = 0; ref_nested().clear();
30269 template<typename V> static inline void enumerate(V& v)
30274 template<typename V> bool decode(size_t index, V& v)
30279 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
30284 template<typename V> bool encode(size_t index, V& v) const
30286 if(index != type) return false;
30294 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
30296 size_t get_index() const {return type;}
30297 bool is_unknown() const { return type == 1; }
30298 void clear() {type = 0;}
30299 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
30300 template<typename V> bool decode(V& v)
30303 if(!v(ref_nested())) return false;
30304 { type = 1; return true;}
30308 template<typename V> bool encode(V& v) const
30310 return v(ref_nested());
30314 template<typename V> bool decode(size_t index, V& v)
30319 case 1: type = 1; return v(ref_nested());
30320 ref_nested().clear();
30325 template<typename V> bool encode(size_t index, V& v) const
30327 if(index != type) {return false;} return v(ref_nested());
30337 S1TNLLoadIndicator ::= SEQUENCE {
30338 dLS1TNLLoadIndicator LoadIndicator,
30339 uLS1TNLLoadIndicator LoadIndicator,
30340 iE-Extensions ProtocolExtensionContainer { {S1TNLLoadIndicator-ExtIEs} } OPTIONAL,
30345 struct S1TNLLoadIndicator : asn::sequence<3, 0, true, 1>
30347 static constexpr const char* name() {return "S1TNLLoadIndicator";}
30348 using parent_t = asn::sequence<3, 0, true, 1>;
30349 struct dLS1TNLLoadIndicator_t : LoadIndicator
30351 static constexpr const char* name() {return "dLS1TNLLoadIndicator_t";}
30352 using parent_t = LoadIndicator;
30355 dLS1TNLLoadIndicator_t& ref_dLS1TNLLoadIndicator() {return dLS1TNLLoadIndicator;}
30356 dLS1TNLLoadIndicator_t const& ref_dLS1TNLLoadIndicator() const {return dLS1TNLLoadIndicator;}
30357 struct uLS1TNLLoadIndicator_t : LoadIndicator
30359 static constexpr const char* name() {return "uLS1TNLLoadIndicator_t";}
30360 using parent_t = LoadIndicator;
30363 uLS1TNLLoadIndicator_t& ref_uLS1TNLLoadIndicator() {return uLS1TNLLoadIndicator;}
30364 uLS1TNLLoadIndicator_t const& ref_uLS1TNLLoadIndicator() const {return uLS1TNLLoadIndicator;}
30365 struct iE_Extensions_t : ProtocolExtensionContainer<S1TNLLoadIndicator_ExtIEs>
30367 static constexpr const char* name() {return "iE_Extensions_t";}
30368 using parent_t = ProtocolExtensionContainer<S1TNLLoadIndicator_ExtIEs>;
30369 static constexpr bool optional = true;
30372 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
30373 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
30374 template<typename V> void decode(V& v)
30376 v(dLS1TNLLoadIndicator);
30377 v(uLS1TNLLoadIndicator);
30381 template<typename V> void encode(V& v) const
30383 v(dLS1TNLLoadIndicator);
30384 v(uLS1TNLLoadIndicator);
30390 dLS1TNLLoadIndicator.clear();
30391 uLS1TNLLoadIndicator.clear();
30392 iE_Extensions.clear();
30396 dLS1TNLLoadIndicator_t dLS1TNLLoadIndicator;
30397 uLS1TNLLoadIndicator_t uLS1TNLLoadIndicator;
30398 iE_Extensions_t iE_Extensions;
30402 SCGChangeIndication ::= ENUMERATED {pDCPCountWrapAround, pSCellChange, other, ...}
30405 struct SCGChangeIndication : asn::enumerated<3, 0, true>
30407 static constexpr const char* name() {return "SCGChangeIndication";}
30408 using parent_t = asn::enumerated<3, 0, true>;
30410 pDCPCountWrapAround
30418 SCGConfigurationQuery ::= ENUMERATED {true,...}
30421 struct SCGConfigurationQuery : asn::enumerated<1, 0, true>
30423 static constexpr const char* name() {return "SCGConfigurationQuery";}
30424 using parent_t = asn::enumerated<1, 0, true>;
30432 SGNB-Addition-Trigger-Ind ::= ENUMERATED {
30440 struct SGNB_Addition_Trigger_Ind : asn::enumerated<3, 0, true>
30442 static constexpr const char* name() {return "SGNB-Addition-Trigger-Ind";}
30443 using parent_t = asn::enumerated<3, 0, true>;
30453 SIPTOBearerDeactivationIndication ::= ENUMERATED {
30459 struct SIPTOBearerDeactivationIndication : asn::enumerated<1, 0, true>
30461 static constexpr const char* name() {return "SIPTOBearerDeactivationIndication";}
30462 using parent_t = asn::enumerated<1, 0, true>;
30470 SRBType ::= ENUMERATED {srb1, srb2, ...}
30473 struct SRBType : asn::enumerated<2, 0, true>
30475 static constexpr const char* name() {return "SRBType";}
30476 using parent_t = asn::enumerated<2, 0, true>;
30485 SRVCCOperationPossible ::= ENUMERATED {
30491 struct SRVCCOperationPossible : asn::enumerated<1, 0, true>
30493 static constexpr const char* name() {return "SRVCCOperationPossible";}
30494 using parent_t = asn::enumerated<1, 0, true>;
30502 ScheduledCommunicationTime-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
30507 struct ScheduledCommunicationTime_ExtIEs
30509 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
30511 size_t get_index() const {return type;}
30512 bool is_unknown() const { return type == 1; }
30513 void clear() {type = 0;}
30514 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
30515 template<typename V> bool decode(V& v)
30518 if(!v(ref_nested())) return false;
30519 { type = 1; return true;}
30523 template<typename V> bool encode(V& v) const
30525 return v(ref_nested());
30529 template<typename V> bool decode(size_t index, V& v)
30534 case 1: type = 1; return v(ref_nested());
30535 ref_nested().clear();
30540 template<typename V> bool encode(size_t index, V& v) const
30542 if(index != type) {return false;} return v(ref_nested());
30549 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
30551 size_t get_index() const {return type;}
30552 bool is_unknown() const { return type == 1; }
30553 void clear() {type = 0;}
30554 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
30555 template<typename V> bool decode(V& v)
30558 if(!v(ref_nested())) return false;
30559 { type = 1; return true;}
30563 template<typename V> bool encode(V& v) const
30565 return v(ref_nested());
30569 template<typename V> bool decode(size_t index, V& v)
30574 case 1: type = 1; return v(ref_nested());
30575 ref_nested().clear();
30580 template<typename V> bool encode(size_t index, V& v) const
30582 if(index != type) {return false;} return v(ref_nested());
30589 struct Extension_t : asn::typefield<true>
30591 ~Extension_t() {clear();}
30592 size_t get_index() const {return type;}
30593 bool is_unknown() const { return type == 1; }
30596 type = 0; ref_nested().clear();
30598 template<typename V> static inline void enumerate(V& v)
30603 template<typename V> bool decode(size_t index, V& v)
30608 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
30613 template<typename V> bool encode(size_t index, V& v) const
30615 if(index != type) return false;
30623 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
30625 size_t get_index() const {return type;}
30626 bool is_unknown() const { return type == 1; }
30627 void clear() {type = 0;}
30628 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
30629 template<typename V> bool decode(V& v)
30632 if(!v(ref_nested())) return false;
30633 { type = 1; return true;}
30637 template<typename V> bool encode(V& v) const
30639 return v(ref_nested());
30643 template<typename V> bool decode(size_t index, V& v)
30648 case 1: type = 1; return v(ref_nested());
30649 ref_nested().clear();
30654 template<typename V> bool encode(size_t index, V& v) const
30656 if(index != type) {return false;} return v(ref_nested());
30666 ScheduledCommunicationTime ::= SEQUENCE {
30667 dayofWeek BIT STRING (SIZE(7)) OPTIONAL,
30668 timeofDayStart INTEGER (0..86399, ...) OPTIONAL,
30669 timeofDayEnd INTEGER (0..86399, ...) OPTIONAL,
30670 iE-Extensions ProtocolExtensionContainer { { ScheduledCommunicationTime-ExtIEs}} OPTIONAL,
30675 struct ScheduledCommunicationTime : asn::sequence<4, 0, true, 4>
30677 static constexpr const char* name() {return "ScheduledCommunicationTime";}
30678 using parent_t = asn::sequence<4, 0, true, 4>;
30679 struct dayofWeek_t : asn::bstring<>
30681 using constraint_t = asn::constraints<false,asn::one<7>>;
30682 static constexpr const char* name() {return "dayofWeek_t";}
30683 using parent_t = asn::bstring<>;
30684 static constexpr bool optional = true;
30688 dayofWeek_t& set_dayofWeek() { dayofWeek.setpresent(true); return dayofWeek;}
30689 dayofWeek_t const* get_dayofWeek() const {return dayofWeek.is_valid() ? &dayofWeek : nullptr;}
30690 struct timeofDayStart_t : asn::integer<>
30692 using constraint_t = asn::constraints<true,asn::span<0, 86399>>;
30693 static constexpr const char* name() {return "timeofDayStart_t";}
30694 using parent_t = asn::integer<>;
30695 static constexpr bool optional = true;
30699 timeofDayStart_t& set_timeofDayStart() { timeofDayStart.setpresent(true); return timeofDayStart;}
30700 timeofDayStart_t const* get_timeofDayStart() const {return timeofDayStart.is_valid() ? &timeofDayStart : nullptr;}
30701 struct timeofDayEnd_t : asn::integer<>
30703 using constraint_t = asn::constraints<true,asn::span<0, 86399>>;
30704 static constexpr const char* name() {return "timeofDayEnd_t";}
30705 using parent_t = asn::integer<>;
30706 static constexpr bool optional = true;
30710 timeofDayEnd_t& set_timeofDayEnd() { timeofDayEnd.setpresent(true); return timeofDayEnd;}
30711 timeofDayEnd_t const* get_timeofDayEnd() const {return timeofDayEnd.is_valid() ? &timeofDayEnd : nullptr;}
30712 struct iE_Extensions_t : ProtocolExtensionContainer<ScheduledCommunicationTime_ExtIEs>
30714 static constexpr const char* name() {return "iE_Extensions_t";}
30715 using parent_t = ProtocolExtensionContainer<ScheduledCommunicationTime_ExtIEs>;
30716 static constexpr bool optional = true;
30719 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
30720 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
30721 template<typename V> void decode(V& v)
30729 template<typename V> void encode(V& v) const
30740 timeofDayStart.clear();
30741 timeofDayEnd.clear();
30742 iE_Extensions.clear();
30746 dayofWeek_t dayofWeek;
30747 timeofDayStart_t timeofDayStart;
30748 timeofDayEnd_t timeofDayEnd;
30749 iE_Extensions_t iE_Extensions;
30753 SeNBSecurityKey ::= BIT STRING (SIZE(256))
30756 struct SeNBSecurityKey : asn::bstring<>
30758 using constraint_t = asn::constraints<false,asn::one<256>>;
30759 static constexpr const char* name() {return "SeNBSecurityKey";}
30760 using parent_t = asn::bstring<>;
30765 SeNBtoMeNBContainer ::= OCTET STRING
30768 struct SeNBtoMeNBContainer : asn::ostring<>
30770 static constexpr const char* name() {return "SeNBtoMeNBContainer";}
30771 using parent_t = asn::ostring<>;
30776 SecondaryRATUsageReport-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
30781 struct SecondaryRATUsageReport_Item_ExtIEs
30783 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
30785 size_t get_index() const {return type;}
30786 bool is_unknown() const { return type == 1; }
30787 void clear() {type = 0;}
30788 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
30789 template<typename V> bool decode(V& v)
30792 if(!v(ref_nested())) return false;
30793 { type = 1; return true;}
30797 template<typename V> bool encode(V& v) const
30799 return v(ref_nested());
30803 template<typename V> bool decode(size_t index, V& v)
30808 case 1: type = 1; return v(ref_nested());
30809 ref_nested().clear();
30814 template<typename V> bool encode(size_t index, V& v) const
30816 if(index != type) {return false;} return v(ref_nested());
30823 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
30825 size_t get_index() const {return type;}
30826 bool is_unknown() const { return type == 1; }
30827 void clear() {type = 0;}
30828 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
30829 template<typename V> bool decode(V& v)
30832 if(!v(ref_nested())) return false;
30833 { type = 1; return true;}
30837 template<typename V> bool encode(V& v) const
30839 return v(ref_nested());
30843 template<typename V> bool decode(size_t index, V& v)
30848 case 1: type = 1; return v(ref_nested());
30849 ref_nested().clear();
30854 template<typename V> bool encode(size_t index, V& v) const
30856 if(index != type) {return false;} return v(ref_nested());
30863 struct Extension_t : asn::typefield<true>
30865 ~Extension_t() {clear();}
30866 size_t get_index() const {return type;}
30867 bool is_unknown() const { return type == 1; }
30870 type = 0; ref_nested().clear();
30872 template<typename V> static inline void enumerate(V& v)
30877 template<typename V> bool decode(size_t index, V& v)
30882 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
30887 template<typename V> bool encode(size_t index, V& v) const
30889 if(index != type) return false;
30897 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
30899 size_t get_index() const {return type;}
30900 bool is_unknown() const { return type == 1; }
30901 void clear() {type = 0;}
30902 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
30903 template<typename V> bool decode(V& v)
30906 if(!v(ref_nested())) return false;
30907 { type = 1; return true;}
30911 template<typename V> bool encode(V& v) const
30913 return v(ref_nested());
30917 template<typename V> bool decode(size_t index, V& v)
30922 case 1: type = 1; return v(ref_nested());
30923 ref_nested().clear();
30928 template<typename V> bool encode(size_t index, V& v) const
30930 if(index != type) {return false;} return v(ref_nested());
30940 SecondaryRATUsageReport-Item ::= SEQUENCE {
30942 secondaryRATType ENUMERATED {nr, ...},
30943 e-RABUsageReportList E-RABUsageReportList,
30944 iE-Extensions ProtocolExtensionContainer { {SecondaryRATUsageReport-Item-ExtIEs} } OPTIONAL,
30949 struct SecondaryRATUsageReport_Item : asn::sequence<4, 0, true, 1>
30951 static constexpr const char* name() {return "SecondaryRATUsageReport-Item";}
30952 using parent_t = asn::sequence<4, 0, true, 1>;
30953 struct e_RAB_ID_t : E_RAB_ID
30955 static constexpr const char* name() {return "e_RAB_ID_t";}
30956 using parent_t = E_RAB_ID;
30959 e_RAB_ID_t& ref_e_RAB_ID() {return e_RAB_ID;}
30960 e_RAB_ID_t const& ref_e_RAB_ID() const {return e_RAB_ID;}
30961 struct secondaryRATType_t : asn::enumerated<1, 0, true>
30963 static constexpr const char* name() {return "secondaryRATType_t";}
30964 using parent_t = asn::enumerated<1, 0, true>;
30971 secondaryRATType_t& ref_secondaryRATType() {return secondaryRATType;}
30972 secondaryRATType_t const& ref_secondaryRATType() const {return secondaryRATType;}
30973 struct e_RABUsageReportList_t : E_RABUsageReportList
30975 static constexpr const char* name() {return "e_RABUsageReportList_t";}
30976 using parent_t = E_RABUsageReportList;
30979 e_RABUsageReportList_t& ref_e_RABUsageReportList() {return e_RABUsageReportList;}
30980 e_RABUsageReportList_t const& ref_e_RABUsageReportList() const {return e_RABUsageReportList;}
30981 struct iE_Extensions_t : ProtocolExtensionContainer<SecondaryRATUsageReport_Item_ExtIEs>
30983 static constexpr const char* name() {return "iE_Extensions_t";}
30984 using parent_t = ProtocolExtensionContainer<SecondaryRATUsageReport_Item_ExtIEs>;
30985 static constexpr bool optional = true;
30988 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
30989 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
30990 template<typename V> void decode(V& v)
30993 v(secondaryRATType);
30994 v(e_RABUsageReportList);
30998 template<typename V> void encode(V& v) const
31001 v(secondaryRATType);
31002 v(e_RABUsageReportList);
31009 secondaryRATType.clear();
31010 e_RABUsageReportList.clear();
31011 iE_Extensions.clear();
31015 e_RAB_ID_t e_RAB_ID;
31016 secondaryRATType_t secondaryRATType;
31017 e_RABUsageReportList_t e_RABUsageReportList;
31018 iE_Extensions_t iE_Extensions;
31022 SecondaryRATUsageReport-ItemIEs X2AP-PROTOCOL-IES ::= {
31023 { ID id-SecondaryRATUsageReport-Item CRITICALITY reject TYPE SecondaryRATUsageReport-Item PRESENCE mandatory},
31028 struct SecondaryRATUsageReport_ItemIEs
31030 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::id_t, true>
31032 size_t get_index() const {return type;}
31033 bool is_unknown() const { return type == 2; }
31034 void clear() {type = 0;}
31035 void select_id_SecondaryRATUsageReport_Item() { set(id_SecondaryRATUsageReport_Item); type=1;}
31036 X2AP_PROTOCOL_IES::id_t const& ref_value() const {return ref_nested();}
31037 template<typename V> bool decode(V& v)
31040 if(!v(ref_nested())) return false;
31041 if(equal(id_SecondaryRATUsageReport_Item)) { type = 1; return true; }
31042 else { type = 2; return true;}
31046 template<typename V> bool encode(V& v) const
31048 return v(ref_nested());
31052 template<typename V> bool decode(size_t index, V& v)
31057 case 1: type = 1; if(v(ref_nested())) { return equal(id_SecondaryRATUsageReport_Item);} return false;
31058 case 2: type = 2; return v(ref_nested());
31059 ref_nested().clear();
31064 template<typename V> bool encode(size_t index, V& v) const
31066 if(index != type) {return false;} return v(ref_nested());
31073 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::criticality_t, true>
31075 size_t get_index() const {return type;}
31076 bool is_unknown() const { return type == 2; }
31077 void clear() {type = 0;}
31078 void select_id_SecondaryRATUsageReport_Item() { set(reject); type=1;}
31079 X2AP_PROTOCOL_IES::criticality_t const& ref_value() const {return ref_nested();}
31080 template<typename V> bool decode(V& v)
31083 if(!v(ref_nested())) return false;
31084 if(equal(reject)) { type = 1; return true; }
31085 else { type = 2; return true;}
31089 template<typename V> bool encode(V& v) const
31091 return v(ref_nested());
31095 template<typename V> bool decode(size_t index, V& v)
31100 case 1: type = 1; if(v(ref_nested())) { return equal(reject);} return false;
31101 case 2: type = 2; return v(ref_nested());
31102 ref_nested().clear();
31107 template<typename V> bool encode(size_t index, V& v) const
31109 if(index != type) {return false;} return v(ref_nested());
31116 struct Value_t : asn::typefield<true>
31118 ~Value_t() {clear();}
31119 size_t get_index() const {return type;}
31120 SecondaryRATUsageReport_Item& select_id_SecondaryRATUsageReport_Item() { return set<SecondaryRATUsageReport_Item>(1); }
31121 SecondaryRATUsageReport_Item const* get_id_SecondaryRATUsageReport_Item() const { return get<SecondaryRATUsageReport_Item>(1); }
31122 bool is_unknown() const { return type == 2; }
31127 case 1: var.destroy<SecondaryRATUsageReport_Item>(); break;
31129 type = 0; ref_nested().clear();
31131 template<typename V> static inline void enumerate(V& v)
31133 v.template operator()<SecondaryRATUsageReport_Item>(1);
31137 template<typename V> bool decode(size_t index, V& v)
31142 case 1: v(select_id_SecondaryRATUsageReport_Item()); return true;
31143 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
31148 template<typename V> bool encode(size_t index, V& v) const
31150 if(index != type) return false;
31153 case 1: v(var.as<SecondaryRATUsageReport_Item>()); return true;
31159 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
31160 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
31163 char dummy1[sizeof(SecondaryRATUsageReport_Item)];
31166 asn::variant<sizeof(union_type)> var;
31170 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_IES::presence_t, true>
31172 size_t get_index() const {return type;}
31173 bool is_unknown() const { return type == 2; }
31174 void clear() {type = 0;}
31175 void select_id_SecondaryRATUsageReport_Item() { set(mandatory); type=1;}
31176 X2AP_PROTOCOL_IES::presence_t const& ref_value() const {return ref_nested();}
31177 template<typename V> bool decode(V& v)
31180 if(!v(ref_nested())) return false;
31181 if(equal(mandatory)) { type = 1; return true; }
31182 else { type = 2; return true;}
31186 template<typename V> bool encode(V& v) const
31188 return v(ref_nested());
31192 template<typename V> bool decode(size_t index, V& v)
31197 case 1: type = 1; if(v(ref_nested())) { return equal(mandatory);} return false;
31198 case 2: type = 2; return v(ref_nested());
31199 ref_nested().clear();
31204 template<typename V> bool encode(size_t index, V& v) const
31206 if(index != type) {return false;} return v(ref_nested());
31216 SecondaryRATUsageReportList ::= SEQUENCE (SIZE(1..maxnoofBearers)) OF ProtocolIE-Single-Container {{SecondaryRATUsageReport-ItemIEs}}
31219 struct SecondaryRATUsageReportList_elm : ProtocolIE_Single_Container<SecondaryRATUsageReport_ItemIEs>
31221 static constexpr const char* name() {return "SecondaryRATUsageReportList_elm";}
31222 using parent_t = ProtocolIE_Single_Container<SecondaryRATUsageReport_ItemIEs>;
31225 struct SecondaryRATUsageReportList : asn::sequenceof<SecondaryRATUsageReportList_elm>
31227 static constexpr const char* name() {return "SecondaryRATUsageReportList";}
31228 using parent_t = asn::sequenceof<SecondaryRATUsageReportList_elm>;
31229 using constraint_t = asn::constraints<false,asn::span<1, maxnoofBearers >>;
31233 ServedCell-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31238 struct ServedCell_ExtIEs
31240 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31242 size_t get_index() const {return type;}
31243 bool is_unknown() const { return type == 1; }
31244 void clear() {type = 0;}
31245 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31246 template<typename V> bool decode(V& v)
31249 if(!v(ref_nested())) return false;
31250 { type = 1; return true;}
31254 template<typename V> bool encode(V& v) const
31256 return v(ref_nested());
31260 template<typename V> bool decode(size_t index, V& v)
31265 case 1: type = 1; return v(ref_nested());
31266 ref_nested().clear();
31271 template<typename V> bool encode(size_t index, V& v) const
31273 if(index != type) {return false;} return v(ref_nested());
31280 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31282 size_t get_index() const {return type;}
31283 bool is_unknown() const { return type == 1; }
31284 void clear() {type = 0;}
31285 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31286 template<typename V> bool decode(V& v)
31289 if(!v(ref_nested())) return false;
31290 { type = 1; return true;}
31294 template<typename V> bool encode(V& v) const
31296 return v(ref_nested());
31300 template<typename V> bool decode(size_t index, V& v)
31305 case 1: type = 1; return v(ref_nested());
31306 ref_nested().clear();
31311 template<typename V> bool encode(size_t index, V& v) const
31313 if(index != type) {return false;} return v(ref_nested());
31320 struct Extension_t : asn::typefield<true>
31322 ~Extension_t() {clear();}
31323 size_t get_index() const {return type;}
31324 bool is_unknown() const { return type == 1; }
31327 type = 0; ref_nested().clear();
31329 template<typename V> static inline void enumerate(V& v)
31334 template<typename V> bool decode(size_t index, V& v)
31339 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
31344 template<typename V> bool encode(size_t index, V& v) const
31346 if(index != type) return false;
31354 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
31356 size_t get_index() const {return type;}
31357 bool is_unknown() const { return type == 1; }
31358 void clear() {type = 0;}
31359 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
31360 template<typename V> bool decode(V& v)
31363 if(!v(ref_nested())) return false;
31364 { type = 1; return true;}
31368 template<typename V> bool encode(V& v) const
31370 return v(ref_nested());
31374 template<typename V> bool decode(size_t index, V& v)
31379 case 1: type = 1; return v(ref_nested());
31380 ref_nested().clear();
31385 template<typename V> bool encode(size_t index, V& v) const
31387 if(index != type) {return false;} return v(ref_nested());
31397 ServedCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31398 { ID id-Number-of-Antennaports CRITICALITY ignore EXTENSION Number-of-Antennaports PRESENCE optional}|
31399 { ID id-PRACH-Configuration CRITICALITY ignore EXTENSION PRACH-Configuration PRESENCE optional}|
31400 { ID id-MBSFN-Subframe-Info CRITICALITY ignore EXTENSION MBSFN-Subframe-Infolist PRESENCE optional}|
31401 { ID id-CSG-Id CRITICALITY ignore EXTENSION CSG-Id PRESENCE optional}|
31402 { ID id-MBMS-Service-Area-List CRITICALITY ignore EXTENSION MBMS-Service-Area-Identity-List PRESENCE optional}|
31403 { ID id-MultibandInfoList CRITICALITY ignore EXTENSION MultibandInfoList PRESENCE optional}|
31404 { ID id-FreqBandIndicatorPriority CRITICALITY ignore EXTENSION FreqBandIndicatorPriority PRESENCE optional}|
31405 { ID id-BandwidthReducedSI CRITICALITY ignore EXTENSION BandwidthReducedSI PRESENCE optional}|
31406 { ID id-ProtectedEUTRAResourceIndication CRITICALITY ignore EXTENSION ProtectedEUTRAResourceIndication PRESENCE optional},
31411 struct ServedCell_Information_ExtIEs
31413 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31415 size_t get_index() const {return type;}
31416 bool is_unknown() const { return type == 10; }
31417 void clear() {type = 0;}
31418 void select_id_Number_of_Antennaports() { set(id_Number_of_Antennaports); type=1;}
31419 void select_id_PRACH_Configuration() { set(id_PRACH_Configuration); type=2;}
31420 void select_id_MBSFN_Subframe_Info() { set(id_MBSFN_Subframe_Info); type=3;}
31421 void select_id_CSG_Id() { set(id_CSG_Id); type=4;}
31422 void select_id_MBMS_Service_Area_List() { set(id_MBMS_Service_Area_List); type=5;}
31423 void select_id_MultibandInfoList() { set(id_MultibandInfoList); type=6;}
31424 void select_id_FreqBandIndicatorPriority() { set(id_FreqBandIndicatorPriority); type=7;}
31425 void select_id_BandwidthReducedSI() { set(id_BandwidthReducedSI); type=8;}
31426 void select_id_ProtectedEUTRAResourceIndication() { set(id_ProtectedEUTRAResourceIndication); type=9;}
31427 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31428 template<typename V> bool decode(V& v)
31431 if(!v(ref_nested())) return false;
31432 if(equal(id_Number_of_Antennaports)) { type = 1; return true; }
31433 else if(equal(id_PRACH_Configuration)) { type = 2; return true; }
31434 else if(equal(id_MBSFN_Subframe_Info)) { type = 3; return true; }
31435 else if(equal(id_CSG_Id)) { type = 4; return true; }
31436 else if(equal(id_MBMS_Service_Area_List)) { type = 5; return true; }
31437 else if(equal(id_MultibandInfoList)) { type = 6; return true; }
31438 else if(equal(id_FreqBandIndicatorPriority)) { type = 7; return true; }
31439 else if(equal(id_BandwidthReducedSI)) { type = 8; return true; }
31440 else if(equal(id_ProtectedEUTRAResourceIndication)) { type = 9; return true; }
31441 else { type = 10; return true;}
31445 template<typename V> bool encode(V& v) const
31447 return v(ref_nested());
31451 template<typename V> bool decode(size_t index, V& v)
31456 case 1: type = 1; if(v(ref_nested())) { return equal(id_Number_of_Antennaports);} return false;
31457 case 2: type = 2; if(v(ref_nested())) { return equal(id_PRACH_Configuration);} return false;
31458 case 3: type = 3; if(v(ref_nested())) { return equal(id_MBSFN_Subframe_Info);} return false;
31459 case 4: type = 4; if(v(ref_nested())) { return equal(id_CSG_Id);} return false;
31460 case 5: type = 5; if(v(ref_nested())) { return equal(id_MBMS_Service_Area_List);} return false;
31461 case 6: type = 6; if(v(ref_nested())) { return equal(id_MultibandInfoList);} return false;
31462 case 7: type = 7; if(v(ref_nested())) { return equal(id_FreqBandIndicatorPriority);} return false;
31463 case 8: type = 8; if(v(ref_nested())) { return equal(id_BandwidthReducedSI);} return false;
31464 case 9: type = 9; if(v(ref_nested())) { return equal(id_ProtectedEUTRAResourceIndication);} return false;
31465 case 10: type = 10; return v(ref_nested());
31466 ref_nested().clear();
31471 template<typename V> bool encode(size_t index, V& v) const
31473 if(index != type) {return false;} return v(ref_nested());
31480 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
31482 size_t get_index() const {return type;}
31483 bool is_unknown() const { return type == 10; }
31484 void clear() {type = 0;}
31485 void select_id_Number_of_Antennaports() { set(ignore); type=1;}
31486 void select_id_PRACH_Configuration() { set(ignore); type=2;}
31487 void select_id_MBSFN_Subframe_Info() { set(ignore); type=3;}
31488 void select_id_CSG_Id() { set(ignore); type=4;}
31489 void select_id_MBMS_Service_Area_List() { set(ignore); type=5;}
31490 void select_id_MultibandInfoList() { set(ignore); type=6;}
31491 void select_id_FreqBandIndicatorPriority() { set(ignore); type=7;}
31492 void select_id_BandwidthReducedSI() { set(ignore); type=8;}
31493 void select_id_ProtectedEUTRAResourceIndication() { set(ignore); type=9;}
31494 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
31495 template<typename V> bool decode(V& v)
31498 if(!v(ref_nested())) return false;
31499 if(equal(ignore)) { type = 1; return true; }
31500 else if(equal(ignore)) { type = 2; return true; }
31501 else if(equal(ignore)) { type = 3; return true; }
31502 else if(equal(ignore)) { type = 4; return true; }
31503 else if(equal(ignore)) { type = 5; return true; }
31504 else if(equal(ignore)) { type = 6; return true; }
31505 else if(equal(ignore)) { type = 7; return true; }
31506 else if(equal(ignore)) { type = 8; return true; }
31507 else if(equal(ignore)) { type = 9; return true; }
31508 else { type = 10; return true;}
31512 template<typename V> bool encode(V& v) const
31514 return v(ref_nested());
31518 template<typename V> bool decode(size_t index, V& v)
31523 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
31524 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
31525 case 3: type = 3; if(v(ref_nested())) { return equal(ignore);} return false;
31526 case 4: type = 4; if(v(ref_nested())) { return equal(ignore);} return false;
31527 case 5: type = 5; if(v(ref_nested())) { return equal(ignore);} return false;
31528 case 6: type = 6; if(v(ref_nested())) { return equal(ignore);} return false;
31529 case 7: type = 7; if(v(ref_nested())) { return equal(ignore);} return false;
31530 case 8: type = 8; if(v(ref_nested())) { return equal(ignore);} return false;
31531 case 9: type = 9; if(v(ref_nested())) { return equal(ignore);} return false;
31532 case 10: type = 10; return v(ref_nested());
31533 ref_nested().clear();
31538 template<typename V> bool encode(size_t index, V& v) const
31540 if(index != type) {return false;} return v(ref_nested());
31547 struct Extension_t : asn::typefield<true>
31549 ~Extension_t() {clear();}
31550 size_t get_index() const {return type;}
31551 Number_of_Antennaports& select_id_Number_of_Antennaports() { return set<Number_of_Antennaports>(1); }
31552 Number_of_Antennaports const* get_id_Number_of_Antennaports() const { return get<Number_of_Antennaports>(1); }
31553 PRACH_Configuration& select_id_PRACH_Configuration() { return set<PRACH_Configuration>(2); }
31554 PRACH_Configuration const* get_id_PRACH_Configuration() const { return get<PRACH_Configuration>(2); }
31555 MBSFN_Subframe_Infolist& select_id_MBSFN_Subframe_Info() { return set<MBSFN_Subframe_Infolist>(3); }
31556 MBSFN_Subframe_Infolist const* get_id_MBSFN_Subframe_Info() const { return get<MBSFN_Subframe_Infolist>(3); }
31557 CSG_Id& select_id_CSG_Id() { return set<CSG_Id>(4); }
31558 CSG_Id const* get_id_CSG_Id() const { return get<CSG_Id>(4); }
31559 MBMS_Service_Area_Identity_List& select_id_MBMS_Service_Area_List() { return set<MBMS_Service_Area_Identity_List>(5); }
31560 MBMS_Service_Area_Identity_List const* get_id_MBMS_Service_Area_List() const { return get<MBMS_Service_Area_Identity_List>(5); }
31561 MultibandInfoList& select_id_MultibandInfoList() { return set<MultibandInfoList>(6); }
31562 MultibandInfoList const* get_id_MultibandInfoList() const { return get<MultibandInfoList>(6); }
31563 FreqBandIndicatorPriority& select_id_FreqBandIndicatorPriority() { return set<FreqBandIndicatorPriority>(7); }
31564 FreqBandIndicatorPriority const* get_id_FreqBandIndicatorPriority() const { return get<FreqBandIndicatorPriority>(7); }
31565 BandwidthReducedSI& select_id_BandwidthReducedSI() { return set<BandwidthReducedSI>(8); }
31566 BandwidthReducedSI const* get_id_BandwidthReducedSI() const { return get<BandwidthReducedSI>(8); }
31567 ProtectedEUTRAResourceIndication& select_id_ProtectedEUTRAResourceIndication() { return set<ProtectedEUTRAResourceIndication>(9); }
31568 ProtectedEUTRAResourceIndication const* get_id_ProtectedEUTRAResourceIndication() const { return get<ProtectedEUTRAResourceIndication>(9); }
31569 bool is_unknown() const { return type == 10; }
31574 case 1: var.destroy<Number_of_Antennaports>(); break;
31575 case 2: var.destroy<PRACH_Configuration>(); break;
31576 case 3: var.destroy<MBSFN_Subframe_Infolist>(); break;
31577 case 4: var.destroy<CSG_Id>(); break;
31578 case 5: var.destroy<MBMS_Service_Area_Identity_List>(); break;
31579 case 6: var.destroy<MultibandInfoList>(); break;
31580 case 7: var.destroy<FreqBandIndicatorPriority>(); break;
31581 case 8: var.destroy<BandwidthReducedSI>(); break;
31582 case 9: var.destroy<ProtectedEUTRAResourceIndication>(); break;
31584 type = 0; ref_nested().clear();
31586 template<typename V> static inline void enumerate(V& v)
31588 v.template operator()<Number_of_Antennaports>(1);
31589 v.template operator()<PRACH_Configuration>(2);
31590 v.template operator()<MBSFN_Subframe_Infolist>(3);
31591 v.template operator()<CSG_Id>(4);
31592 v.template operator()<MBMS_Service_Area_Identity_List>(5);
31593 v.template operator()<MultibandInfoList>(6);
31594 v.template operator()<FreqBandIndicatorPriority>(7);
31595 v.template operator()<BandwidthReducedSI>(8);
31596 v.template operator()<ProtectedEUTRAResourceIndication>(9);
31600 template<typename V> bool decode(size_t index, V& v)
31605 case 1: v(select_id_Number_of_Antennaports()); return true;
31606 case 2: v(select_id_PRACH_Configuration()); return true;
31607 case 3: v(select_id_MBSFN_Subframe_Info()); return true;
31608 case 4: v(select_id_CSG_Id()); return true;
31609 case 5: v(select_id_MBMS_Service_Area_List()); return true;
31610 case 6: v(select_id_MultibandInfoList()); return true;
31611 case 7: v(select_id_FreqBandIndicatorPriority()); return true;
31612 case 8: v(select_id_BandwidthReducedSI()); return true;
31613 case 9: v(select_id_ProtectedEUTRAResourceIndication()); return true;
31614 case 10: if(type != 10) {clear(); asn::base::set();} type = 10; return true;
31619 template<typename V> bool encode(size_t index, V& v) const
31621 if(index != type) return false;
31624 case 1: v(var.as<Number_of_Antennaports>()); return true;
31625 case 2: v(var.as<PRACH_Configuration>()); return true;
31626 case 3: v(var.as<MBSFN_Subframe_Infolist>()); return true;
31627 case 4: v(var.as<CSG_Id>()); return true;
31628 case 5: v(var.as<MBMS_Service_Area_Identity_List>()); return true;
31629 case 6: v(var.as<MultibandInfoList>()); return true;
31630 case 7: v(var.as<FreqBandIndicatorPriority>()); return true;
31631 case 8: v(var.as<BandwidthReducedSI>()); return true;
31632 case 9: v(var.as<ProtectedEUTRAResourceIndication>()); return true;
31638 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
31639 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
31642 char dummy1[sizeof(BandwidthReducedSI)];
31643 char dummy2[sizeof(CSG_Id)];
31644 char dummy3[sizeof(FreqBandIndicatorPriority)];
31645 char dummy4[sizeof(MBMS_Service_Area_Identity_List)];
31646 char dummy5[sizeof(MBSFN_Subframe_Infolist)];
31647 char dummy6[sizeof(MultibandInfoList)];
31648 char dummy7[sizeof(Number_of_Antennaports)];
31649 char dummy8[sizeof(PRACH_Configuration)];
31650 char dummy9[sizeof(ProtectedEUTRAResourceIndication)];
31653 asn::variant<sizeof(union_type)> var;
31657 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
31659 size_t get_index() const {return type;}
31660 bool is_unknown() const { return type == 10; }
31661 void clear() {type = 0;}
31662 void select_id_Number_of_Antennaports() { set(optional); type=1;}
31663 void select_id_PRACH_Configuration() { set(optional); type=2;}
31664 void select_id_MBSFN_Subframe_Info() { set(optional); type=3;}
31665 void select_id_CSG_Id() { set(optional); type=4;}
31666 void select_id_MBMS_Service_Area_List() { set(optional); type=5;}
31667 void select_id_MultibandInfoList() { set(optional); type=6;}
31668 void select_id_FreqBandIndicatorPriority() { set(optional); type=7;}
31669 void select_id_BandwidthReducedSI() { set(optional); type=8;}
31670 void select_id_ProtectedEUTRAResourceIndication() { set(optional); type=9;}
31671 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
31672 template<typename V> bool decode(V& v)
31675 if(!v(ref_nested())) return false;
31676 if(equal(optional)) { type = 1; return true; }
31677 else if(equal(optional)) { type = 2; return true; }
31678 else if(equal(optional)) { type = 3; return true; }
31679 else if(equal(optional)) { type = 4; return true; }
31680 else if(equal(optional)) { type = 5; return true; }
31681 else if(equal(optional)) { type = 6; return true; }
31682 else if(equal(optional)) { type = 7; return true; }
31683 else if(equal(optional)) { type = 8; return true; }
31684 else if(equal(optional)) { type = 9; return true; }
31685 else { type = 10; return true;}
31689 template<typename V> bool encode(V& v) const
31691 return v(ref_nested());
31695 template<typename V> bool decode(size_t index, V& v)
31700 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
31701 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
31702 case 3: type = 3; if(v(ref_nested())) { return equal(optional);} return false;
31703 case 4: type = 4; if(v(ref_nested())) { return equal(optional);} return false;
31704 case 5: type = 5; if(v(ref_nested())) { return equal(optional);} return false;
31705 case 6: type = 6; if(v(ref_nested())) { return equal(optional);} return false;
31706 case 7: type = 7; if(v(ref_nested())) { return equal(optional);} return false;
31707 case 8: type = 8; if(v(ref_nested())) { return equal(optional);} return false;
31708 case 9: type = 9; if(v(ref_nested())) { return equal(optional);} return false;
31709 case 10: type = 10; return v(ref_nested());
31710 ref_nested().clear();
31715 template<typename V> bool encode(size_t index, V& v) const
31717 if(index != type) {return false;} return v(ref_nested());
31727 ServedCell-Information ::= SEQUENCE {
31731 broadcastPLMNs BroadcastPLMNs-Item,
31732 eUTRA-Mode-Info EUTRA-Mode-Info,
31733 iE-Extensions ProtocolExtensionContainer { {ServedCell-Information-ExtIEs} } OPTIONAL,
31738 struct ServedCell_Information : asn::sequence<6, 0, true, 1>
31740 static constexpr const char* name() {return "ServedCell-Information";}
31741 using parent_t = asn::sequence<6, 0, true, 1>;
31744 static constexpr const char* name() {return "pCI_t";}
31745 using parent_t = PCI;
31748 pCI_t& ref_pCI() {return pCI;}
31749 pCI_t const& ref_pCI() const {return pCI;}
31750 struct cellId_t : ECGI
31752 static constexpr const char* name() {return "cellId_t";}
31753 using parent_t = ECGI;
31756 cellId_t& ref_cellId() {return cellId;}
31757 cellId_t const& ref_cellId() const {return cellId;}
31760 static constexpr const char* name() {return "tAC_t";}
31761 using parent_t = TAC;
31764 tAC_t& ref_tAC() {return tAC;}
31765 tAC_t const& ref_tAC() const {return tAC;}
31766 struct broadcastPLMNs_t : BroadcastPLMNs_Item
31768 static constexpr const char* name() {return "broadcastPLMNs_t";}
31769 using parent_t = BroadcastPLMNs_Item;
31772 broadcastPLMNs_t& ref_broadcastPLMNs() {return broadcastPLMNs;}
31773 broadcastPLMNs_t const& ref_broadcastPLMNs() const {return broadcastPLMNs;}
31774 struct eUTRA_Mode_Info_t : EUTRA_Mode_Info
31776 static constexpr const char* name() {return "eUTRA_Mode_Info_t";}
31777 using parent_t = EUTRA_Mode_Info;
31780 eUTRA_Mode_Info_t& ref_eUTRA_Mode_Info() {return eUTRA_Mode_Info;}
31781 eUTRA_Mode_Info_t const& ref_eUTRA_Mode_Info() const {return eUTRA_Mode_Info;}
31782 struct iE_Extensions_t : ProtocolExtensionContainer<ServedCell_Information_ExtIEs>
31784 static constexpr const char* name() {return "iE_Extensions_t";}
31785 using parent_t = ProtocolExtensionContainer<ServedCell_Information_ExtIEs>;
31786 static constexpr bool optional = true;
31789 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
31790 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
31791 template<typename V> void decode(V& v)
31797 v(eUTRA_Mode_Info);
31801 template<typename V> void encode(V& v) const
31807 v(eUTRA_Mode_Info);
31816 broadcastPLMNs.clear();
31817 eUTRA_Mode_Info.clear();
31818 iE_Extensions.clear();
31825 broadcastPLMNs_t broadcastPLMNs;
31826 eUTRA_Mode_Info_t eUTRA_Mode_Info;
31827 iE_Extensions_t iE_Extensions;
31831 ServedCells ::= SEQUENCE (SIZE (1.. maxCellineNB)) OF SEQUENCE {
31832 servedCellInfo ServedCell-Information,
31833 neighbour-Info Neighbour-Information OPTIONAL,
31834 iE-Extensions ProtocolExtensionContainer { {ServedCell-ExtIEs} } OPTIONAL,
31839 struct ServedCells_elm : asn::sequence<3, 0, true, 2>
31841 static constexpr const char* name() {return "ServedCells_elm";}
31842 using parent_t = asn::sequence<3, 0, true, 2>;
31843 struct servedCellInfo_t : ServedCell_Information
31845 static constexpr const char* name() {return "servedCellInfo_t";}
31846 using parent_t = ServedCell_Information;
31849 servedCellInfo_t& ref_servedCellInfo() {return servedCellInfo;}
31850 servedCellInfo_t const& ref_servedCellInfo() const {return servedCellInfo;}
31851 struct neighbour_Info_t : Neighbour_Information
31853 static constexpr const char* name() {return "neighbour_Info_t";}
31854 using parent_t = Neighbour_Information;
31855 static constexpr bool optional = true;
31858 neighbour_Info_t& set_neighbour_Info() { neighbour_Info.setpresent(true); return neighbour_Info;}
31859 neighbour_Info_t const* get_neighbour_Info() const {return neighbour_Info.is_valid() ? &neighbour_Info : nullptr;}
31860 struct iE_Extensions_t : ProtocolExtensionContainer<ServedCell_ExtIEs>
31862 static constexpr const char* name() {return "iE_Extensions_t";}
31863 using parent_t = ProtocolExtensionContainer<ServedCell_ExtIEs>;
31864 static constexpr bool optional = true;
31867 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
31868 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
31869 template<typename V> void decode(V& v)
31876 template<typename V> void encode(V& v) const
31885 servedCellInfo.clear();
31886 neighbour_Info.clear();
31887 iE_Extensions.clear();
31891 servedCellInfo_t servedCellInfo;
31892 neighbour_Info_t neighbour_Info;
31893 iE_Extensions_t iE_Extensions;
31896 struct ServedCells : asn::sequenceof<ServedCells_elm>
31898 static constexpr const char* name() {return "ServedCells";}
31899 using parent_t = asn::sequenceof<ServedCells_elm>;
31900 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
31904 ServiceType ::= ENUMERATED{
31905 qMC-for-streaming-service,
31906 qMC-for-MTSI-service,
31911 struct ServiceType : asn::enumerated<2, 0, true>
31913 static constexpr const char* name() {return "ServiceType";}
31914 using parent_t = asn::enumerated<2, 0, true>;
31916 qMC_for_streaming_service
31917 ,qMC_for_MTSI_service
31923 SgNB-UE-X2AP-ID ::= INTEGER (0..4294967295)
31926 struct SgNB_UE_X2AP_ID : asn::integer<>
31928 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
31929 static constexpr const char* name() {return "SgNB-UE-X2AP-ID";}
31930 using parent_t = asn::integer<>;
31935 SgNBCoordinationAssistanceInformation ::= ENUMERATED{
31936 coordination-not-required,
31941 struct SgNBCoordinationAssistanceInformation : asn::enumerated<1, 0, true>
31943 static constexpr const char* name() {return "SgNBCoordinationAssistanceInformation";}
31944 using parent_t = asn::enumerated<1, 0, true>;
31946 coordination_not_required
31952 SgNBResourceCoordinationInformationExtIEs X2AP-PROTOCOL-EXTENSION ::= {
31953 { ID id-ECGI CRITICALITY ignore EXTENSION ECGI PRESENCE optional}|
31954 { ID id-SgNBCoordinationAssistanceInformation CRITICALITY reject EXTENSION SgNBCoordinationAssistanceInformation PRESENCE optional},
31959 struct SgNBResourceCoordinationInformationExtIEs
31961 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
31963 size_t get_index() const {return type;}
31964 bool is_unknown() const { return type == 3; }
31965 void clear() {type = 0;}
31966 void select_id_ECGI() { set(id_ECGI); type=1;}
31967 void select_id_SgNBCoordinationAssistanceInformation() { set(id_SgNBCoordinationAssistanceInformation); type=2;}
31968 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
31969 template<typename V> bool decode(V& v)
31972 if(!v(ref_nested())) return false;
31973 if(equal(id_ECGI)) { type = 1; return true; }
31974 else if(equal(id_SgNBCoordinationAssistanceInformation)) { type = 2; return true; }
31975 else { type = 3; return true;}
31979 template<typename V> bool encode(V& v) const
31981 return v(ref_nested());
31985 template<typename V> bool decode(size_t index, V& v)
31990 case 1: type = 1; if(v(ref_nested())) { return equal(id_ECGI);} return false;
31991 case 2: type = 2; if(v(ref_nested())) { return equal(id_SgNBCoordinationAssistanceInformation);} return false;
31992 case 3: type = 3; return v(ref_nested());
31993 ref_nested().clear();
31998 template<typename V> bool encode(size_t index, V& v) const
32000 if(index != type) {return false;} return v(ref_nested());
32007 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
32009 size_t get_index() const {return type;}
32010 bool is_unknown() const { return type == 3; }
32011 void clear() {type = 0;}
32012 void select_id_ECGI() { set(ignore); type=1;}
32013 void select_id_SgNBCoordinationAssistanceInformation() { set(reject); type=2;}
32014 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
32015 template<typename V> bool decode(V& v)
32018 if(!v(ref_nested())) return false;
32019 if(equal(ignore)) { type = 1; return true; }
32020 else if(equal(reject)) { type = 2; return true; }
32021 else { type = 3; return true;}
32025 template<typename V> bool encode(V& v) const
32027 return v(ref_nested());
32031 template<typename V> bool decode(size_t index, V& v)
32036 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
32037 case 2: type = 2; if(v(ref_nested())) { return equal(reject);} return false;
32038 case 3: type = 3; return v(ref_nested());
32039 ref_nested().clear();
32044 template<typename V> bool encode(size_t index, V& v) const
32046 if(index != type) {return false;} return v(ref_nested());
32053 struct Extension_t : asn::typefield<true>
32055 ~Extension_t() {clear();}
32056 size_t get_index() const {return type;}
32057 ECGI& select_id_ECGI() { return set<ECGI>(1); }
32058 ECGI const* get_id_ECGI() const { return get<ECGI>(1); }
32059 SgNBCoordinationAssistanceInformation& select_id_SgNBCoordinationAssistanceInformation() { return set<SgNBCoordinationAssistanceInformation>(2); }
32060 SgNBCoordinationAssistanceInformation const* get_id_SgNBCoordinationAssistanceInformation() const { return get<SgNBCoordinationAssistanceInformation>(2); }
32061 bool is_unknown() const { return type == 3; }
32066 case 1: var.destroy<ECGI>(); break;
32067 case 2: var.destroy<SgNBCoordinationAssistanceInformation>(); break;
32069 type = 0; ref_nested().clear();
32071 template<typename V> static inline void enumerate(V& v)
32073 v.template operator()<ECGI>(1);
32074 v.template operator()<SgNBCoordinationAssistanceInformation>(2);
32078 template<typename V> bool decode(size_t index, V& v)
32083 case 1: v(select_id_ECGI()); return true;
32084 case 2: v(select_id_SgNBCoordinationAssistanceInformation()); return true;
32085 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
32090 template<typename V> bool encode(size_t index, V& v) const
32092 if(index != type) return false;
32095 case 1: v(var.as<ECGI>()); return true;
32096 case 2: v(var.as<SgNBCoordinationAssistanceInformation>()); return true;
32102 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
32103 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
32106 char dummy1[sizeof(ECGI)];
32107 char dummy2[sizeof(SgNBCoordinationAssistanceInformation)];
32110 asn::variant<sizeof(union_type)> var;
32114 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
32116 size_t get_index() const {return type;}
32117 bool is_unknown() const { return type == 3; }
32118 void clear() {type = 0;}
32119 void select_id_ECGI() { set(optional); type=1;}
32120 void select_id_SgNBCoordinationAssistanceInformation() { set(optional); type=2;}
32121 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
32122 template<typename V> bool decode(V& v)
32125 if(!v(ref_nested())) return false;
32126 if(equal(optional)) { type = 1; return true; }
32127 else if(equal(optional)) { type = 2; return true; }
32128 else { type = 3; return true;}
32132 template<typename V> bool encode(V& v) const
32134 return v(ref_nested());
32138 template<typename V> bool decode(size_t index, V& v)
32143 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
32144 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
32145 case 3: type = 3; return v(ref_nested());
32146 ref_nested().clear();
32151 template<typename V> bool encode(size_t index, V& v) const
32153 if(index != type) {return false;} return v(ref_nested());
32163 SgNBResourceCoordinationInformation ::= SEQUENCE {
32165 uLCoordinationInformation BIT STRING (SIZE(6..4400, ...)),
32166 dLCoordinationInformation BIT STRING (SIZE(6..4400, ...)) OPTIONAL,
32167 iE-Extensions ProtocolExtensionContainer { {SgNBResourceCoordinationInformationExtIEs} } OPTIONAL,
32172 struct SgNBResourceCoordinationInformation : asn::sequence<4, 0, true, 2>
32174 static constexpr const char* name() {return "SgNBResourceCoordinationInformation";}
32175 using parent_t = asn::sequence<4, 0, true, 2>;
32176 struct nR_CGI_t : NRCGI
32178 static constexpr const char* name() {return "nR_CGI_t";}
32179 using parent_t = NRCGI;
32182 nR_CGI_t& ref_nR_CGI() {return nR_CGI;}
32183 nR_CGI_t const& ref_nR_CGI() const {return nR_CGI;}
32184 struct uLCoordinationInformation_t : asn::bstring<>
32186 using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
32187 static constexpr const char* name() {return "uLCoordinationInformation_t";}
32188 using parent_t = asn::bstring<>;
32192 uLCoordinationInformation_t& ref_uLCoordinationInformation() {return uLCoordinationInformation;}
32193 uLCoordinationInformation_t const& ref_uLCoordinationInformation() const {return uLCoordinationInformation;}
32194 struct dLCoordinationInformation_t : asn::bstring<>
32196 using constraint_t = asn::constraints<true,asn::span<6, 4400>>;
32197 static constexpr const char* name() {return "dLCoordinationInformation_t";}
32198 using parent_t = asn::bstring<>;
32199 static constexpr bool optional = true;
32203 dLCoordinationInformation_t& set_dLCoordinationInformation() { dLCoordinationInformation.setpresent(true); return dLCoordinationInformation;}
32204 dLCoordinationInformation_t const* get_dLCoordinationInformation() const {return dLCoordinationInformation.is_valid() ? &dLCoordinationInformation : nullptr;}
32205 struct iE_Extensions_t : ProtocolExtensionContainer<SgNBResourceCoordinationInformationExtIEs>
32207 static constexpr const char* name() {return "iE_Extensions_t";}
32208 using parent_t = ProtocolExtensionContainer<SgNBResourceCoordinationInformationExtIEs>;
32209 static constexpr bool optional = true;
32212 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
32213 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
32214 template<typename V> void decode(V& v)
32217 v(uLCoordinationInformation);
32218 v(dLCoordinationInformation);
32222 template<typename V> void encode(V& v) const
32225 v(uLCoordinationInformation);
32226 v(dLCoordinationInformation);
32233 uLCoordinationInformation.clear();
32234 dLCoordinationInformation.clear();
32235 iE_Extensions.clear();
32240 uLCoordinationInformation_t uLCoordinationInformation;
32241 dLCoordinationInformation_t dLCoordinationInformation;
32242 iE_Extensions_t iE_Extensions;
32246 SgNBSecurityKey ::= BIT STRING (SIZE(256))
32249 struct SgNBSecurityKey : asn::bstring<>
32251 using constraint_t = asn::constraints<false,asn::one<256>>;
32252 static constexpr const char* name() {return "SgNBSecurityKey";}
32253 using parent_t = asn::bstring<>;
32258 SgNBtoMeNBContainer ::= OCTET STRING
32261 struct SgNBtoMeNBContainer : asn::ostring<>
32263 static constexpr const char* name() {return "SgNBtoMeNBContainer";}
32264 using parent_t = asn::ostring<>;
32269 ShortMAC-I ::= BIT STRING (SIZE(16))
32272 struct ShortMAC_I : asn::bstring<>
32274 using constraint_t = asn::constraints<false,asn::one<16>>;
32275 static constexpr const char* name() {return "ShortMAC-I";}
32276 using parent_t = asn::bstring<>;
32281 SpectrumSharingGroupID ::= INTEGER (1..maxCellineNB)
32284 struct SpectrumSharingGroupID : asn::integer<>
32286 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
32287 static constexpr const char* name() {return "SpectrumSharingGroupID";}
32288 using parent_t = asn::integer<>;
32293 SplitSRB-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
32298 struct SplitSRB_ExtIEs
32300 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
32302 size_t get_index() const {return type;}
32303 bool is_unknown() const { return type == 1; }
32304 void clear() {type = 0;}
32305 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
32306 template<typename V> bool decode(V& v)
32309 if(!v(ref_nested())) return false;
32310 { type = 1; return true;}
32314 template<typename V> bool encode(V& v) const
32316 return v(ref_nested());
32320 template<typename V> bool decode(size_t index, V& v)
32325 case 1: type = 1; return v(ref_nested());
32326 ref_nested().clear();
32331 template<typename V> bool encode(size_t index, V& v) const
32333 if(index != type) {return false;} return v(ref_nested());
32340 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
32342 size_t get_index() const {return type;}
32343 bool is_unknown() const { return type == 1; }
32344 void clear() {type = 0;}
32345 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
32346 template<typename V> bool decode(V& v)
32349 if(!v(ref_nested())) return false;
32350 { type = 1; return true;}
32354 template<typename V> bool encode(V& v) const
32356 return v(ref_nested());
32360 template<typename V> bool decode(size_t index, V& v)
32365 case 1: type = 1; return v(ref_nested());
32366 ref_nested().clear();
32371 template<typename V> bool encode(size_t index, V& v) const
32373 if(index != type) {return false;} return v(ref_nested());
32380 struct Extension_t : asn::typefield<true>
32382 ~Extension_t() {clear();}
32383 size_t get_index() const {return type;}
32384 bool is_unknown() const { return type == 1; }
32387 type = 0; ref_nested().clear();
32389 template<typename V> static inline void enumerate(V& v)
32394 template<typename V> bool decode(size_t index, V& v)
32399 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
32404 template<typename V> bool encode(size_t index, V& v) const
32406 if(index != type) return false;
32414 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
32416 size_t get_index() const {return type;}
32417 bool is_unknown() const { return type == 1; }
32418 void clear() {type = 0;}
32419 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
32420 template<typename V> bool decode(V& v)
32423 if(!v(ref_nested())) return false;
32424 { type = 1; return true;}
32428 template<typename V> bool encode(V& v) const
32430 return v(ref_nested());
32434 template<typename V> bool decode(size_t index, V& v)
32439 case 1: type = 1; return v(ref_nested());
32440 ref_nested().clear();
32445 template<typename V> bool encode(size_t index, V& v) const
32447 if(index != type) {return false;} return v(ref_nested());
32457 SplitSRB ::= SEQUENCE {
32458 rrcContainer RRCContainer OPTIONAL,
32460 deliveryStatus DeliveryStatus OPTIONAL,
32461 iE-Extensions ProtocolExtensionContainer { {SplitSRB-ExtIEs} } OPTIONAL,
32466 struct SplitSRB : asn::sequence<4, 0, true, 3>
32468 static constexpr const char* name() {return "SplitSRB";}
32469 using parent_t = asn::sequence<4, 0, true, 3>;
32470 struct rrcContainer_t : RRCContainer
32472 static constexpr const char* name() {return "rrcContainer_t";}
32473 using parent_t = RRCContainer;
32474 static constexpr bool optional = true;
32477 rrcContainer_t& set_rrcContainer() { rrcContainer.setpresent(true); return rrcContainer;}
32478 rrcContainer_t const* get_rrcContainer() const {return rrcContainer.is_valid() ? &rrcContainer : nullptr;}
32479 struct srbType_t : SRBType
32481 static constexpr const char* name() {return "srbType_t";}
32482 using parent_t = SRBType;
32485 srbType_t& ref_srbType() {return srbType;}
32486 srbType_t const& ref_srbType() const {return srbType;}
32487 struct deliveryStatus_t : DeliveryStatus
32489 static constexpr const char* name() {return "deliveryStatus_t";}
32490 using parent_t = DeliveryStatus;
32491 static constexpr bool optional = true;
32494 deliveryStatus_t& set_deliveryStatus() { deliveryStatus.setpresent(true); return deliveryStatus;}
32495 deliveryStatus_t const* get_deliveryStatus() const {return deliveryStatus.is_valid() ? &deliveryStatus : nullptr;}
32496 struct iE_Extensions_t : ProtocolExtensionContainer<SplitSRB_ExtIEs>
32498 static constexpr const char* name() {return "iE_Extensions_t";}
32499 using parent_t = ProtocolExtensionContainer<SplitSRB_ExtIEs>;
32500 static constexpr bool optional = true;
32503 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
32504 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
32505 template<typename V> void decode(V& v)
32513 template<typename V> void encode(V& v) const
32523 rrcContainer.clear();
32525 deliveryStatus.clear();
32526 iE_Extensions.clear();
32530 rrcContainer_t rrcContainer;
32532 deliveryStatus_t deliveryStatus;
32533 iE_Extensions_t iE_Extensions;
32537 SplitSRBs ::= ENUMERATED {srb1, srb2, srb1and2, ...}
32540 struct SplitSRBs : asn::enumerated<3, 0, true>
32542 static constexpr const char* name() {return "SplitSRBs";}
32543 using parent_t = asn::enumerated<3, 0, true>;
32553 SubscriberProfileIDforRFP ::= INTEGER (1..256)
32556 struct SubscriberProfileIDforRFP : asn::integer<>
32558 using constraint_t = asn::constraints<false,asn::span<1, 256>>;
32559 static constexpr const char* name() {return "SubscriberProfileIDforRFP";}
32560 using parent_t = asn::integer<>;
32565 Subscription-Based-UE-DifferentiationInfo-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
32570 struct Subscription_Based_UE_DifferentiationInfo_ExtIEs
32572 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
32574 size_t get_index() const {return type;}
32575 bool is_unknown() const { return type == 1; }
32576 void clear() {type = 0;}
32577 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
32578 template<typename V> bool decode(V& v)
32581 if(!v(ref_nested())) return false;
32582 { type = 1; return true;}
32586 template<typename V> bool encode(V& v) const
32588 return v(ref_nested());
32592 template<typename V> bool decode(size_t index, V& v)
32597 case 1: type = 1; return v(ref_nested());
32598 ref_nested().clear();
32603 template<typename V> bool encode(size_t index, V& v) const
32605 if(index != type) {return false;} return v(ref_nested());
32612 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
32614 size_t get_index() const {return type;}
32615 bool is_unknown() const { return type == 1; }
32616 void clear() {type = 0;}
32617 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
32618 template<typename V> bool decode(V& v)
32621 if(!v(ref_nested())) return false;
32622 { type = 1; return true;}
32626 template<typename V> bool encode(V& v) const
32628 return v(ref_nested());
32632 template<typename V> bool decode(size_t index, V& v)
32637 case 1: type = 1; return v(ref_nested());
32638 ref_nested().clear();
32643 template<typename V> bool encode(size_t index, V& v) const
32645 if(index != type) {return false;} return v(ref_nested());
32652 struct Extension_t : asn::typefield<true>
32654 ~Extension_t() {clear();}
32655 size_t get_index() const {return type;}
32656 bool is_unknown() const { return type == 1; }
32659 type = 0; ref_nested().clear();
32661 template<typename V> static inline void enumerate(V& v)
32666 template<typename V> bool decode(size_t index, V& v)
32671 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
32676 template<typename V> bool encode(size_t index, V& v) const
32678 if(index != type) return false;
32686 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
32688 size_t get_index() const {return type;}
32689 bool is_unknown() const { return type == 1; }
32690 void clear() {type = 0;}
32691 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
32692 template<typename V> bool decode(V& v)
32695 if(!v(ref_nested())) return false;
32696 { type = 1; return true;}
32700 template<typename V> bool encode(V& v) const
32702 return v(ref_nested());
32706 template<typename V> bool decode(size_t index, V& v)
32711 case 1: type = 1; return v(ref_nested());
32712 ref_nested().clear();
32717 template<typename V> bool encode(size_t index, V& v) const
32719 if(index != type) {return false;} return v(ref_nested());
32729 Subscription-Based-UE-DifferentiationInfo ::= SEQUENCE {
32730 periodicCommunicationIndicator ENUMERATED {periodically, ondemand, ...} OPTIONAL,
32731 periodicTime INTEGER (1..3600, ...) OPTIONAL,
32732 scheduledCommunicationTime ScheduledCommunicationTime OPTIONAL,
32733 stationaryIndication ENUMERATED {stationary, mobile, ...} OPTIONAL,
32734 trafficProfile ENUMERATED {single-packet, dual-packets, multiple-packets, ...} OPTIONAL,
32735 batteryIndication ENUMERATED {battery-powered, battery-powered-not-rechargeable-or-replaceable, not-battery-powered, ...} OPTIONAL,
32736 iE-Extensions ProtocolExtensionContainer { { Subscription-Based-UE-DifferentiationInfo-ExtIEs} } OPTIONAL,
32741 struct Subscription_Based_UE_DifferentiationInfo : asn::sequence<7, 0, true, 7>
32743 static constexpr const char* name() {return "Subscription-Based-UE-DifferentiationInfo";}
32744 using parent_t = asn::sequence<7, 0, true, 7>;
32745 struct periodicCommunicationIndicator_t : asn::enumerated<2, 0, true>
32747 static constexpr const char* name() {return "periodicCommunicationIndicator_t";}
32748 using parent_t = asn::enumerated<2, 0, true>;
32749 static constexpr bool optional = true;
32757 periodicCommunicationIndicator_t& set_periodicCommunicationIndicator() { periodicCommunicationIndicator.setpresent(true); return periodicCommunicationIndicator;}
32758 periodicCommunicationIndicator_t const* get_periodicCommunicationIndicator() const {return periodicCommunicationIndicator.is_valid() ? &periodicCommunicationIndicator : nullptr;}
32759 struct periodicTime_t : asn::integer<>
32761 using constraint_t = asn::constraints<true,asn::span<1, 3600>>;
32762 static constexpr const char* name() {return "periodicTime_t";}
32763 using parent_t = asn::integer<>;
32764 static constexpr bool optional = true;
32768 periodicTime_t& set_periodicTime() { periodicTime.setpresent(true); return periodicTime;}
32769 periodicTime_t const* get_periodicTime() const {return periodicTime.is_valid() ? &periodicTime : nullptr;}
32770 struct scheduledCommunicationTime_t : ScheduledCommunicationTime
32772 static constexpr const char* name() {return "scheduledCommunicationTime_t";}
32773 using parent_t = ScheduledCommunicationTime;
32774 static constexpr bool optional = true;
32777 scheduledCommunicationTime_t& set_scheduledCommunicationTime() { scheduledCommunicationTime.setpresent(true); return scheduledCommunicationTime;}
32778 scheduledCommunicationTime_t const* get_scheduledCommunicationTime() const {return scheduledCommunicationTime.is_valid() ? &scheduledCommunicationTime : nullptr;}
32779 struct stationaryIndication_t : asn::enumerated<2, 0, true>
32781 static constexpr const char* name() {return "stationaryIndication_t";}
32782 using parent_t = asn::enumerated<2, 0, true>;
32783 static constexpr bool optional = true;
32791 stationaryIndication_t& set_stationaryIndication() { stationaryIndication.setpresent(true); return stationaryIndication;}
32792 stationaryIndication_t const* get_stationaryIndication() const {return stationaryIndication.is_valid() ? &stationaryIndication : nullptr;}
32793 struct trafficProfile_t : asn::enumerated<3, 0, true>
32795 static constexpr const char* name() {return "trafficProfile_t";}
32796 using parent_t = asn::enumerated<3, 0, true>;
32797 static constexpr bool optional = true;
32806 trafficProfile_t& set_trafficProfile() { trafficProfile.setpresent(true); return trafficProfile;}
32807 trafficProfile_t const* get_trafficProfile() const {return trafficProfile.is_valid() ? &trafficProfile : nullptr;}
32808 struct batteryIndication_t : asn::enumerated<3, 0, true>
32810 static constexpr const char* name() {return "batteryIndication_t";}
32811 using parent_t = asn::enumerated<3, 0, true>;
32812 static constexpr bool optional = true;
32815 ,battery_powered_not_rechargeable_or_replaceable
32816 ,not_battery_powered
32821 batteryIndication_t& set_batteryIndication() { batteryIndication.setpresent(true); return batteryIndication;}
32822 batteryIndication_t const* get_batteryIndication() const {return batteryIndication.is_valid() ? &batteryIndication : nullptr;}
32823 struct iE_Extensions_t : ProtocolExtensionContainer<Subscription_Based_UE_DifferentiationInfo_ExtIEs>
32825 static constexpr const char* name() {return "iE_Extensions_t";}
32826 using parent_t = ProtocolExtensionContainer<Subscription_Based_UE_DifferentiationInfo_ExtIEs>;
32827 static constexpr bool optional = true;
32830 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
32831 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
32832 template<typename V> void decode(V& v)
32834 v(periodicCommunicationIndicator);
32836 v(scheduledCommunicationTime);
32837 v(stationaryIndication);
32839 v(batteryIndication);
32843 template<typename V> void encode(V& v) const
32845 v(periodicCommunicationIndicator);
32847 v(scheduledCommunicationTime);
32848 v(stationaryIndication);
32850 v(batteryIndication);
32856 periodicCommunicationIndicator.clear();
32857 periodicTime.clear();
32858 scheduledCommunicationTime.clear();
32859 stationaryIndication.clear();
32860 trafficProfile.clear();
32861 batteryIndication.clear();
32862 iE_Extensions.clear();
32866 periodicCommunicationIndicator_t periodicCommunicationIndicator;
32867 periodicTime_t periodicTime;
32868 scheduledCommunicationTime_t scheduledCommunicationTime;
32869 stationaryIndication_t stationaryIndication;
32870 trafficProfile_t trafficProfile;
32871 batteryIndication_t batteryIndication;
32872 iE_Extensions_t iE_Extensions;
32876 TargetCellInUTRAN ::= OCTET STRING -- This IE is to be encoded according to the UTRAN Cell ID in the Last Visited UTRAN Cell Information IE in TS 25.413 [24]
32879 struct TargetCellInUTRAN : asn::ostring<>
32881 static constexpr const char* name() {return "TargetCellInUTRAN";}
32882 using parent_t = asn::ostring<>;
32887 TargeteNBtoSource-eNBTransparentContainer ::= OCTET STRING
32890 struct TargeteNBtoSource_eNBTransparentContainer : asn::ostring<>
32892 static constexpr const char* name() {return "TargeteNBtoSource-eNBTransparentContainer";}
32893 using parent_t = asn::ostring<>;
32898 TimeToWait ::= ENUMERATED {
32909 struct TimeToWait : asn::enumerated<6, 0, true>
32911 static constexpr const char* name() {return "TimeToWait";}
32912 using parent_t = asn::enumerated<6, 0, true>;
32925 TraceDepth ::= ENUMERATED {
32929 minimumWithoutVendorSpecificExtension,
32930 mediumWithoutVendorSpecificExtension,
32931 maximumWithoutVendorSpecificExtension,
32936 struct TraceDepth : asn::enumerated<6, 0, true>
32938 static constexpr const char* name() {return "TraceDepth";}
32939 using parent_t = asn::enumerated<6, 0, true>;
32944 ,minimumWithoutVendorSpecificExtension
32945 ,mediumWithoutVendorSpecificExtension
32946 ,maximumWithoutVendorSpecificExtension
32952 TraceCollectionEntityIPAddress ::= BIT STRING (SIZE(1..160, ...))
32955 struct TraceCollectionEntityIPAddress : asn::bstring<>
32957 using constraint_t = asn::constraints<true,asn::span<1, 160>>;
32958 static constexpr const char* name() {return "TraceCollectionEntityIPAddress";}
32959 using parent_t = asn::bstring<>;
32964 UEAppLayerMeasConfig-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
32965 {ID id-serviceType CRITICALITY ignore EXTENSION ServiceType PRESENCE optional},
32970 struct UEAppLayerMeasConfig_ExtIEs
32972 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
32974 size_t get_index() const {return type;}
32975 bool is_unknown() const { return type == 2; }
32976 void clear() {type = 0;}
32977 void select_id_serviceType() { set(id_serviceType); type=1;}
32978 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
32979 template<typename V> bool decode(V& v)
32982 if(!v(ref_nested())) return false;
32983 if(equal(id_serviceType)) { type = 1; return true; }
32984 else { type = 2; return true;}
32988 template<typename V> bool encode(V& v) const
32990 return v(ref_nested());
32994 template<typename V> bool decode(size_t index, V& v)
32999 case 1: type = 1; if(v(ref_nested())) { return equal(id_serviceType);} return false;
33000 case 2: type = 2; return v(ref_nested());
33001 ref_nested().clear();
33006 template<typename V> bool encode(size_t index, V& v) const
33008 if(index != type) {return false;} return v(ref_nested());
33015 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
33017 size_t get_index() const {return type;}
33018 bool is_unknown() const { return type == 2; }
33019 void clear() {type = 0;}
33020 void select_id_serviceType() { set(ignore); type=1;}
33021 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
33022 template<typename V> bool decode(V& v)
33025 if(!v(ref_nested())) return false;
33026 if(equal(ignore)) { type = 1; return true; }
33027 else { type = 2; return true;}
33031 template<typename V> bool encode(V& v) const
33033 return v(ref_nested());
33037 template<typename V> bool decode(size_t index, V& v)
33042 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
33043 case 2: type = 2; return v(ref_nested());
33044 ref_nested().clear();
33049 template<typename V> bool encode(size_t index, V& v) const
33051 if(index != type) {return false;} return v(ref_nested());
33058 struct Extension_t : asn::typefield<true>
33060 ~Extension_t() {clear();}
33061 size_t get_index() const {return type;}
33062 ServiceType& select_id_serviceType() { return set<ServiceType>(1); }
33063 ServiceType const* get_id_serviceType() const { return get<ServiceType>(1); }
33064 bool is_unknown() const { return type == 2; }
33069 case 1: var.destroy<ServiceType>(); break;
33071 type = 0; ref_nested().clear();
33073 template<typename V> static inline void enumerate(V& v)
33075 v.template operator()<ServiceType>(1);
33079 template<typename V> bool decode(size_t index, V& v)
33084 case 1: v(select_id_serviceType()); return true;
33085 case 2: if(type != 2) {clear(); asn::base::set();} type = 2; return true;
33090 template<typename V> bool encode(size_t index, V& v) const
33092 if(index != type) return false;
33095 case 1: v(var.as<ServiceType>()); return true;
33101 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33102 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33105 char dummy1[sizeof(ServiceType)];
33108 asn::variant<sizeof(union_type)> var;
33112 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
33114 size_t get_index() const {return type;}
33115 bool is_unknown() const { return type == 2; }
33116 void clear() {type = 0;}
33117 void select_id_serviceType() { set(optional); type=1;}
33118 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
33119 template<typename V> bool decode(V& v)
33122 if(!v(ref_nested())) return false;
33123 if(equal(optional)) { type = 1; return true; }
33124 else { type = 2; return true;}
33128 template<typename V> bool encode(V& v) const
33130 return v(ref_nested());
33134 template<typename V> bool decode(size_t index, V& v)
33139 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
33140 case 2: type = 2; return v(ref_nested());
33141 ref_nested().clear();
33146 template<typename V> bool encode(size_t index, V& v) const
33148 if(index != type) {return false;} return v(ref_nested());
33158 UEAppLayerMeasConfig ::= SEQUENCE {
33159 containerForAppLayerMeasConfig OCTET STRING (SIZE(1..1000)),
33160 areaScopeOfQMC AreaScopeOfQMC,
33161 iE-Extensions ProtocolExtensionContainer { {UEAppLayerMeasConfig-ExtIEs} } OPTIONAL,
33166 struct UEAppLayerMeasConfig : asn::sequence<3, 0, true, 1>
33168 static constexpr const char* name() {return "UEAppLayerMeasConfig";}
33169 using parent_t = asn::sequence<3, 0, true, 1>;
33170 struct containerForAppLayerMeasConfig_t : asn::ostring<>
33172 using constraint_t = asn::constraints<false,asn::span<1, 1000>>;
33173 static constexpr const char* name() {return "containerForAppLayerMeasConfig_t";}
33174 using parent_t = asn::ostring<>;
33178 containerForAppLayerMeasConfig_t& ref_containerForAppLayerMeasConfig() {return containerForAppLayerMeasConfig;}
33179 containerForAppLayerMeasConfig_t const& ref_containerForAppLayerMeasConfig() const {return containerForAppLayerMeasConfig;}
33180 struct areaScopeOfQMC_t : AreaScopeOfQMC
33182 static constexpr const char* name() {return "areaScopeOfQMC_t";}
33183 using parent_t = AreaScopeOfQMC;
33186 areaScopeOfQMC_t& ref_areaScopeOfQMC() {return areaScopeOfQMC;}
33187 areaScopeOfQMC_t const& ref_areaScopeOfQMC() const {return areaScopeOfQMC;}
33188 struct iE_Extensions_t : ProtocolExtensionContainer<UEAppLayerMeasConfig_ExtIEs>
33190 static constexpr const char* name() {return "iE_Extensions_t";}
33191 using parent_t = ProtocolExtensionContainer<UEAppLayerMeasConfig_ExtIEs>;
33192 static constexpr bool optional = true;
33195 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
33196 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
33197 template<typename V> void decode(V& v)
33199 v(containerForAppLayerMeasConfig);
33204 template<typename V> void encode(V& v) const
33206 v(containerForAppLayerMeasConfig);
33213 containerForAppLayerMeasConfig.clear();
33214 areaScopeOfQMC.clear();
33215 iE_Extensions.clear();
33219 containerForAppLayerMeasConfig_t containerForAppLayerMeasConfig;
33220 areaScopeOfQMC_t areaScopeOfQMC;
33221 iE_Extensions_t iE_Extensions;
33225 TraceActivation-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
33226 { ID id-MDTConfiguration CRITICALITY ignore EXTENSION MDT-Configuration PRESENCE optional}|
33227 { ID id-UEAppLayerMeasConfig CRITICALITY ignore EXTENSION UEAppLayerMeasConfig PRESENCE optional},
33232 struct TraceActivation_ExtIEs
33234 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
33236 size_t get_index() const {return type;}
33237 bool is_unknown() const { return type == 3; }
33238 void clear() {type = 0;}
33239 void select_id_MDTConfiguration() { set(id_MDTConfiguration); type=1;}
33240 void select_id_UEAppLayerMeasConfig() { set(id_UEAppLayerMeasConfig); type=2;}
33241 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
33242 template<typename V> bool decode(V& v)
33245 if(!v(ref_nested())) return false;
33246 if(equal(id_MDTConfiguration)) { type = 1; return true; }
33247 else if(equal(id_UEAppLayerMeasConfig)) { type = 2; return true; }
33248 else { type = 3; return true;}
33252 template<typename V> bool encode(V& v) const
33254 return v(ref_nested());
33258 template<typename V> bool decode(size_t index, V& v)
33263 case 1: type = 1; if(v(ref_nested())) { return equal(id_MDTConfiguration);} return false;
33264 case 2: type = 2; if(v(ref_nested())) { return equal(id_UEAppLayerMeasConfig);} return false;
33265 case 3: type = 3; return v(ref_nested());
33266 ref_nested().clear();
33271 template<typename V> bool encode(size_t index, V& v) const
33273 if(index != type) {return false;} return v(ref_nested());
33280 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
33282 size_t get_index() const {return type;}
33283 bool is_unknown() const { return type == 3; }
33284 void clear() {type = 0;}
33285 void select_id_MDTConfiguration() { set(ignore); type=1;}
33286 void select_id_UEAppLayerMeasConfig() { set(ignore); type=2;}
33287 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
33288 template<typename V> bool decode(V& v)
33291 if(!v(ref_nested())) return false;
33292 if(equal(ignore)) { type = 1; return true; }
33293 else if(equal(ignore)) { type = 2; return true; }
33294 else { type = 3; return true;}
33298 template<typename V> bool encode(V& v) const
33300 return v(ref_nested());
33304 template<typename V> bool decode(size_t index, V& v)
33309 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
33310 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
33311 case 3: type = 3; return v(ref_nested());
33312 ref_nested().clear();
33317 template<typename V> bool encode(size_t index, V& v) const
33319 if(index != type) {return false;} return v(ref_nested());
33326 struct Extension_t : asn::typefield<true>
33328 ~Extension_t() {clear();}
33329 size_t get_index() const {return type;}
33330 MDT_Configuration& select_id_MDTConfiguration() { return set<MDT_Configuration>(1); }
33331 MDT_Configuration const* get_id_MDTConfiguration() const { return get<MDT_Configuration>(1); }
33332 UEAppLayerMeasConfig& select_id_UEAppLayerMeasConfig() { return set<UEAppLayerMeasConfig>(2); }
33333 UEAppLayerMeasConfig const* get_id_UEAppLayerMeasConfig() const { return get<UEAppLayerMeasConfig>(2); }
33334 bool is_unknown() const { return type == 3; }
33339 case 1: var.destroy<MDT_Configuration>(); break;
33340 case 2: var.destroy<UEAppLayerMeasConfig>(); break;
33342 type = 0; ref_nested().clear();
33344 template<typename V> static inline void enumerate(V& v)
33346 v.template operator()<MDT_Configuration>(1);
33347 v.template operator()<UEAppLayerMeasConfig>(2);
33351 template<typename V> bool decode(size_t index, V& v)
33356 case 1: v(select_id_MDTConfiguration()); return true;
33357 case 2: v(select_id_UEAppLayerMeasConfig()); return true;
33358 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
33363 template<typename V> bool encode(size_t index, V& v) const
33365 if(index != type) return false;
33368 case 1: v(var.as<MDT_Configuration>()); return true;
33369 case 2: v(var.as<UEAppLayerMeasConfig>()); return true;
33375 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
33376 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
33379 char dummy1[sizeof(MDT_Configuration)];
33380 char dummy2[sizeof(UEAppLayerMeasConfig)];
33383 asn::variant<sizeof(union_type)> var;
33387 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
33389 size_t get_index() const {return type;}
33390 bool is_unknown() const { return type == 3; }
33391 void clear() {type = 0;}
33392 void select_id_MDTConfiguration() { set(optional); type=1;}
33393 void select_id_UEAppLayerMeasConfig() { set(optional); type=2;}
33394 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
33395 template<typename V> bool decode(V& v)
33398 if(!v(ref_nested())) return false;
33399 if(equal(optional)) { type = 1; return true; }
33400 else if(equal(optional)) { type = 2; return true; }
33401 else { type = 3; return true;}
33405 template<typename V> bool encode(V& v) const
33407 return v(ref_nested());
33411 template<typename V> bool decode(size_t index, V& v)
33416 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
33417 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
33418 case 3: type = 3; return v(ref_nested());
33419 ref_nested().clear();
33424 template<typename V> bool encode(size_t index, V& v) const
33426 if(index != type) {return false;} return v(ref_nested());
33436 TraceActivation ::= SEQUENCE {
33437 eUTRANTraceID EUTRANTraceID,
33438 interfacesToTrace InterfacesToTrace,
33439 traceDepth TraceDepth,
33440 traceCollectionEntityIPAddress TraceCollectionEntityIPAddress,
33441 iE-Extensions ProtocolExtensionContainer { {TraceActivation-ExtIEs} } OPTIONAL,
33446 struct TraceActivation : asn::sequence<5, 0, true, 1>
33448 static constexpr const char* name() {return "TraceActivation";}
33449 using parent_t = asn::sequence<5, 0, true, 1>;
33450 struct eUTRANTraceID_t : EUTRANTraceID
33452 static constexpr const char* name() {return "eUTRANTraceID_t";}
33453 using parent_t = EUTRANTraceID;
33456 eUTRANTraceID_t& ref_eUTRANTraceID() {return eUTRANTraceID;}
33457 eUTRANTraceID_t const& ref_eUTRANTraceID() const {return eUTRANTraceID;}
33458 struct interfacesToTrace_t : InterfacesToTrace
33460 static constexpr const char* name() {return "interfacesToTrace_t";}
33461 using parent_t = InterfacesToTrace;
33464 interfacesToTrace_t& ref_interfacesToTrace() {return interfacesToTrace;}
33465 interfacesToTrace_t const& ref_interfacesToTrace() const {return interfacesToTrace;}
33466 struct traceDepth_t : TraceDepth
33468 static constexpr const char* name() {return "traceDepth_t";}
33469 using parent_t = TraceDepth;
33472 traceDepth_t& ref_traceDepth() {return traceDepth;}
33473 traceDepth_t const& ref_traceDepth() const {return traceDepth;}
33474 struct traceCollectionEntityIPAddress_t : TraceCollectionEntityIPAddress
33476 static constexpr const char* name() {return "traceCollectionEntityIPAddress_t";}
33477 using parent_t = TraceCollectionEntityIPAddress;
33480 traceCollectionEntityIPAddress_t& ref_traceCollectionEntityIPAddress() {return traceCollectionEntityIPAddress;}
33481 traceCollectionEntityIPAddress_t const& ref_traceCollectionEntityIPAddress() const {return traceCollectionEntityIPAddress;}
33482 struct iE_Extensions_t : ProtocolExtensionContainer<TraceActivation_ExtIEs>
33484 static constexpr const char* name() {return "iE_Extensions_t";}
33485 using parent_t = ProtocolExtensionContainer<TraceActivation_ExtIEs>;
33486 static constexpr bool optional = true;
33489 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
33490 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
33491 template<typename V> void decode(V& v)
33494 v(interfacesToTrace);
33496 v(traceCollectionEntityIPAddress);
33500 template<typename V> void encode(V& v) const
33503 v(interfacesToTrace);
33505 v(traceCollectionEntityIPAddress);
33511 eUTRANTraceID.clear();
33512 interfacesToTrace.clear();
33513 traceDepth.clear();
33514 traceCollectionEntityIPAddress.clear();
33515 iE_Extensions.clear();
33519 eUTRANTraceID_t eUTRANTraceID;
33520 interfacesToTrace_t interfacesToTrace;
33521 traceDepth_t traceDepth;
33522 traceCollectionEntityIPAddress_t traceCollectionEntityIPAddress;
33523 iE_Extensions_t iE_Extensions;
33527 Tunnel-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
33532 struct Tunnel_Information_ExtIEs
33534 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
33536 size_t get_index() const {return type;}
33537 bool is_unknown() const { return type == 1; }
33538 void clear() {type = 0;}
33539 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
33540 template<typename V> bool decode(V& v)
33543 if(!v(ref_nested())) return false;
33544 { type = 1; return true;}
33548 template<typename V> bool encode(V& v) const
33550 return v(ref_nested());
33554 template<typename V> bool decode(size_t index, V& v)
33559 case 1: type = 1; return v(ref_nested());
33560 ref_nested().clear();
33565 template<typename V> bool encode(size_t index, V& v) const
33567 if(index != type) {return false;} return v(ref_nested());
33574 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
33576 size_t get_index() const {return type;}
33577 bool is_unknown() const { return type == 1; }
33578 void clear() {type = 0;}
33579 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
33580 template<typename V> bool decode(V& v)
33583 if(!v(ref_nested())) return false;
33584 { type = 1; return true;}
33588 template<typename V> bool encode(V& v) const
33590 return v(ref_nested());
33594 template<typename V> bool decode(size_t index, V& v)
33599 case 1: type = 1; return v(ref_nested());
33600 ref_nested().clear();
33605 template<typename V> bool encode(size_t index, V& v) const
33607 if(index != type) {return false;} return v(ref_nested());
33614 struct Extension_t : asn::typefield<true>
33616 ~Extension_t() {clear();}
33617 size_t get_index() const {return type;}
33618 bool is_unknown() const { return type == 1; }
33621 type = 0; ref_nested().clear();
33623 template<typename V> static inline void enumerate(V& v)
33628 template<typename V> bool decode(size_t index, V& v)
33633 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
33638 template<typename V> bool encode(size_t index, V& v) const
33640 if(index != type) return false;
33648 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
33650 size_t get_index() const {return type;}
33651 bool is_unknown() const { return type == 1; }
33652 void clear() {type = 0;}
33653 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
33654 template<typename V> bool decode(V& v)
33657 if(!v(ref_nested())) return false;
33658 { type = 1; return true;}
33662 template<typename V> bool encode(V& v) const
33664 return v(ref_nested());
33668 template<typename V> bool decode(size_t index, V& v)
33673 case 1: type = 1; return v(ref_nested());
33674 ref_nested().clear();
33679 template<typename V> bool encode(size_t index, V& v) const
33681 if(index != type) {return false;} return v(ref_nested());
33691 TunnelInformation ::= SEQUENCE {
33692 transportLayerAddress TransportLayerAddress,
33693 uDP-Port-Number Port-Number OPTIONAL,
33694 iE-Extensions ProtocolExtensionContainer { {Tunnel-Information-ExtIEs} } OPTIONAL,
33699 struct TunnelInformation : asn::sequence<3, 0, true, 2>
33701 static constexpr const char* name() {return "TunnelInformation";}
33702 using parent_t = asn::sequence<3, 0, true, 2>;
33703 struct transportLayerAddress_t : TransportLayerAddress
33705 static constexpr const char* name() {return "transportLayerAddress_t";}
33706 using parent_t = TransportLayerAddress;
33709 transportLayerAddress_t& ref_transportLayerAddress() {return transportLayerAddress;}
33710 transportLayerAddress_t const& ref_transportLayerAddress() const {return transportLayerAddress;}
33711 struct uDP_Port_Number_t : Port_Number
33713 static constexpr const char* name() {return "uDP_Port_Number_t";}
33714 using parent_t = Port_Number;
33715 static constexpr bool optional = true;
33718 uDP_Port_Number_t& set_uDP_Port_Number() { uDP_Port_Number.setpresent(true); return uDP_Port_Number;}
33719 uDP_Port_Number_t const* get_uDP_Port_Number() const {return uDP_Port_Number.is_valid() ? &uDP_Port_Number : nullptr;}
33720 struct iE_Extensions_t : ProtocolExtensionContainer<Tunnel_Information_ExtIEs>
33722 static constexpr const char* name() {return "iE_Extensions_t";}
33723 using parent_t = ProtocolExtensionContainer<Tunnel_Information_ExtIEs>;
33724 static constexpr bool optional = true;
33727 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
33728 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
33729 template<typename V> void decode(V& v)
33731 v(transportLayerAddress);
33732 v(uDP_Port_Number);
33736 template<typename V> void encode(V& v) const
33738 v(transportLayerAddress);
33739 v(uDP_Port_Number);
33745 transportLayerAddress.clear();
33746 uDP_Port_Number.clear();
33747 iE_Extensions.clear();
33751 transportLayerAddress_t transportLayerAddress;
33752 uDP_Port_Number_t uDP_Port_Number;
33753 iE_Extensions_t iE_Extensions;
33757 UE-ContextKeptIndicator ::= ENUMERATED {
33763 struct UE_ContextKeptIndicator : asn::enumerated<1, 0, true>
33765 static constexpr const char* name() {return "UE-ContextKeptIndicator";}
33766 using parent_t = asn::enumerated<1, 0, true>;
33774 UE-HistoryInformation ::= SEQUENCE (SIZE(1..maxnoofCells)) OF LastVisitedCell-Item
33777 struct UE_HistoryInformation_elm : LastVisitedCell_Item
33779 static constexpr const char* name() {return "UE_HistoryInformation_elm";}
33780 using parent_t = LastVisitedCell_Item;
33783 struct UE_HistoryInformation : asn::sequenceof<UE_HistoryInformation_elm>
33785 static constexpr const char* name() {return "UE-HistoryInformation";}
33786 using parent_t = asn::sequenceof<UE_HistoryInformation_elm>;
33787 using constraint_t = asn::constraints<false,asn::span<1, maxnoofCells >>;
33791 UE-HistoryInformationFromTheUE ::= OCTET STRING
33794 struct UE_HistoryInformationFromTheUE : asn::ostring<>
33796 static constexpr const char* name() {return "UE-HistoryInformationFromTheUE";}
33797 using parent_t = asn::ostring<>;
33802 UE-RLF-Report-Container::= OCTET STRING
33805 struct UE_RLF_Report_Container : asn::ostring<>
33807 static constexpr const char* name() {return "UE-RLF-Report-Container";}
33808 using parent_t = asn::ostring<>;
33813 UE-RLF-Report-Container-for-extended-bands ::= OCTET STRING
33816 struct UE_RLF_Report_Container_for_extended_bands : asn::ostring<>
33818 static constexpr const char* name() {return "UE-RLF-Report-Container-for-extended-bands";}
33819 using parent_t = asn::ostring<>;
33824 UE-S1AP-ID ::= INTEGER (0.. 4294967295)
33827 struct UE_S1AP_ID : asn::integer<>
33829 using constraint_t = asn::constraints<false,asn::span<0, 4294967295>>;
33830 static constexpr const char* name() {return "UE-S1AP-ID";}
33831 using parent_t = asn::integer<>;
33836 UE-Sidelink-Aggregate-MaximumBitRate-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
33841 struct UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs
33843 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
33845 size_t get_index() const {return type;}
33846 bool is_unknown() const { return type == 1; }
33847 void clear() {type = 0;}
33848 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
33849 template<typename V> bool decode(V& v)
33852 if(!v(ref_nested())) return false;
33853 { type = 1; return true;}
33857 template<typename V> bool encode(V& v) const
33859 return v(ref_nested());
33863 template<typename V> bool decode(size_t index, V& v)
33868 case 1: type = 1; return v(ref_nested());
33869 ref_nested().clear();
33874 template<typename V> bool encode(size_t index, V& v) const
33876 if(index != type) {return false;} return v(ref_nested());
33883 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
33885 size_t get_index() const {return type;}
33886 bool is_unknown() const { return type == 1; }
33887 void clear() {type = 0;}
33888 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
33889 template<typename V> bool decode(V& v)
33892 if(!v(ref_nested())) return false;
33893 { type = 1; return true;}
33897 template<typename V> bool encode(V& v) const
33899 return v(ref_nested());
33903 template<typename V> bool decode(size_t index, V& v)
33908 case 1: type = 1; return v(ref_nested());
33909 ref_nested().clear();
33914 template<typename V> bool encode(size_t index, V& v) const
33916 if(index != type) {return false;} return v(ref_nested());
33923 struct Extension_t : asn::typefield<true>
33925 ~Extension_t() {clear();}
33926 size_t get_index() const {return type;}
33927 bool is_unknown() const { return type == 1; }
33930 type = 0; ref_nested().clear();
33932 template<typename V> static inline void enumerate(V& v)
33937 template<typename V> bool decode(size_t index, V& v)
33942 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
33947 template<typename V> bool encode(size_t index, V& v) const
33949 if(index != type) return false;
33957 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
33959 size_t get_index() const {return type;}
33960 bool is_unknown() const { return type == 1; }
33961 void clear() {type = 0;}
33962 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
33963 template<typename V> bool decode(V& v)
33966 if(!v(ref_nested())) return false;
33967 { type = 1; return true;}
33971 template<typename V> bool encode(V& v) const
33973 return v(ref_nested());
33977 template<typename V> bool decode(size_t index, V& v)
33982 case 1: type = 1; return v(ref_nested());
33983 ref_nested().clear();
33988 template<typename V> bool encode(size_t index, V& v) const
33990 if(index != type) {return false;} return v(ref_nested());
34000 UE-X2AP-ID ::= INTEGER (0..4095)
34003 struct UE_X2AP_ID : asn::integer<>
34005 using constraint_t = asn::constraints<false,asn::span<0, 4095>>;
34006 static constexpr const char* name() {return "UE-X2AP-ID";}
34007 using parent_t = asn::integer<>;
34012 UE-X2AP-ID-Extension ::= INTEGER (0..4095, ...)
34015 struct UE_X2AP_ID_Extension : asn::integer<>
34017 using constraint_t = asn::constraints<true,asn::span<0, 4095>>;
34018 static constexpr const char* name() {return "UE-X2AP-ID-Extension";}
34019 using parent_t = asn::integer<>;
34024 UEAggregate-MaximumBitrate-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
34025 { ID id-extended-uEaggregateMaximumBitRateDownlink CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional}|
34026 { ID id-extended-uEaggregateMaximumBitRateUplink CRITICALITY ignore EXTENSION ExtendedBitRate PRESENCE optional},
34031 struct UEAggregate_MaximumBitrate_ExtIEs
34033 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
34035 size_t get_index() const {return type;}
34036 bool is_unknown() const { return type == 3; }
34037 void clear() {type = 0;}
34038 void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(id_extended_uEaggregateMaximumBitRateDownlink); type=1;}
34039 void select_id_extended_uEaggregateMaximumBitRateUplink() { set(id_extended_uEaggregateMaximumBitRateUplink); type=2;}
34040 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
34041 template<typename V> bool decode(V& v)
34044 if(!v(ref_nested())) return false;
34045 if(equal(id_extended_uEaggregateMaximumBitRateDownlink)) { type = 1; return true; }
34046 else if(equal(id_extended_uEaggregateMaximumBitRateUplink)) { type = 2; return true; }
34047 else { type = 3; return true;}
34051 template<typename V> bool encode(V& v) const
34053 return v(ref_nested());
34057 template<typename V> bool decode(size_t index, V& v)
34062 case 1: type = 1; if(v(ref_nested())) { return equal(id_extended_uEaggregateMaximumBitRateDownlink);} return false;
34063 case 2: type = 2; if(v(ref_nested())) { return equal(id_extended_uEaggregateMaximumBitRateUplink);} return false;
34064 case 3: type = 3; return v(ref_nested());
34065 ref_nested().clear();
34070 template<typename V> bool encode(size_t index, V& v) const
34072 if(index != type) {return false;} return v(ref_nested());
34079 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
34081 size_t get_index() const {return type;}
34082 bool is_unknown() const { return type == 3; }
34083 void clear() {type = 0;}
34084 void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(ignore); type=1;}
34085 void select_id_extended_uEaggregateMaximumBitRateUplink() { set(ignore); type=2;}
34086 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
34087 template<typename V> bool decode(V& v)
34090 if(!v(ref_nested())) return false;
34091 if(equal(ignore)) { type = 1; return true; }
34092 else if(equal(ignore)) { type = 2; return true; }
34093 else { type = 3; return true;}
34097 template<typename V> bool encode(V& v) const
34099 return v(ref_nested());
34103 template<typename V> bool decode(size_t index, V& v)
34108 case 1: type = 1; if(v(ref_nested())) { return equal(ignore);} return false;
34109 case 2: type = 2; if(v(ref_nested())) { return equal(ignore);} return false;
34110 case 3: type = 3; return v(ref_nested());
34111 ref_nested().clear();
34116 template<typename V> bool encode(size_t index, V& v) const
34118 if(index != type) {return false;} return v(ref_nested());
34125 struct Extension_t : asn::typefield<true>
34127 ~Extension_t() {clear();}
34128 size_t get_index() const {return type;}
34129 ExtendedBitRate& select_id_extended_uEaggregateMaximumBitRateDownlink() { return set<ExtendedBitRate>(1); }
34130 ExtendedBitRate const* get_id_extended_uEaggregateMaximumBitRateDownlink() const { return get<ExtendedBitRate>(1); }
34131 ExtendedBitRate& select_id_extended_uEaggregateMaximumBitRateUplink() { return set<ExtendedBitRate>(2); }
34132 ExtendedBitRate const* get_id_extended_uEaggregateMaximumBitRateUplink() const { return get<ExtendedBitRate>(2); }
34133 bool is_unknown() const { return type == 3; }
34138 case 1: var.destroy<ExtendedBitRate>(); break;
34139 case 2: var.destroy<ExtendedBitRate>(); break;
34141 type = 0; ref_nested().clear();
34143 template<typename V> static inline void enumerate(V& v)
34145 v.template operator()<ExtendedBitRate>(1);
34146 v.template operator()<ExtendedBitRate>(2);
34150 template<typename V> bool decode(size_t index, V& v)
34155 case 1: v(select_id_extended_uEaggregateMaximumBitRateDownlink()); return true;
34156 case 2: v(select_id_extended_uEaggregateMaximumBitRateUplink()); return true;
34157 case 3: if(type != 3) {clear(); asn::base::set();} type = 3; return true;
34162 template<typename V> bool encode(size_t index, V& v) const
34164 if(index != type) return false;
34167 case 1: v(var.as<ExtendedBitRate>()); return true;
34168 case 2: v(var.as<ExtendedBitRate>()); return true;
34174 template<class T> T& set(size_t index) {if(type != index) {clear(); type = index; return var.build<T>();} return var.as<T>();}
34175 template<class T> T const* get(size_t index) const {if(type == index) {return &var.as<T>();} return nullptr;}
34178 char dummy1[sizeof(ExtendedBitRate)];
34181 asn::variant<sizeof(union_type)> var;
34185 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
34187 size_t get_index() const {return type;}
34188 bool is_unknown() const { return type == 3; }
34189 void clear() {type = 0;}
34190 void select_id_extended_uEaggregateMaximumBitRateDownlink() { set(optional); type=1;}
34191 void select_id_extended_uEaggregateMaximumBitRateUplink() { set(optional); type=2;}
34192 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
34193 template<typename V> bool decode(V& v)
34196 if(!v(ref_nested())) return false;
34197 if(equal(optional)) { type = 1; return true; }
34198 else if(equal(optional)) { type = 2; return true; }
34199 else { type = 3; return true;}
34203 template<typename V> bool encode(V& v) const
34205 return v(ref_nested());
34209 template<typename V> bool decode(size_t index, V& v)
34214 case 1: type = 1; if(v(ref_nested())) { return equal(optional);} return false;
34215 case 2: type = 2; if(v(ref_nested())) { return equal(optional);} return false;
34216 case 3: type = 3; return v(ref_nested());
34217 ref_nested().clear();
34222 template<typename V> bool encode(size_t index, V& v) const
34224 if(index != type) {return false;} return v(ref_nested());
34234 UEAggregateMaximumBitRate ::= SEQUENCE {
34235 uEaggregateMaximumBitRateDownlink BitRate,
34236 uEaggregateMaximumBitRateUplink BitRate,
34237 iE-Extensions ProtocolExtensionContainer { {UEAggregate-MaximumBitrate-ExtIEs} } OPTIONAL,
34242 struct UEAggregateMaximumBitRate : asn::sequence<3, 0, true, 1>
34244 static constexpr const char* name() {return "UEAggregateMaximumBitRate";}
34245 using parent_t = asn::sequence<3, 0, true, 1>;
34246 struct uEaggregateMaximumBitRateDownlink_t : BitRate
34248 static constexpr const char* name() {return "uEaggregateMaximumBitRateDownlink_t";}
34249 using parent_t = BitRate;
34252 uEaggregateMaximumBitRateDownlink_t& ref_uEaggregateMaximumBitRateDownlink() {return uEaggregateMaximumBitRateDownlink;}
34253 uEaggregateMaximumBitRateDownlink_t const& ref_uEaggregateMaximumBitRateDownlink() const {return uEaggregateMaximumBitRateDownlink;}
34254 struct uEaggregateMaximumBitRateUplink_t : BitRate
34256 static constexpr const char* name() {return "uEaggregateMaximumBitRateUplink_t";}
34257 using parent_t = BitRate;
34260 uEaggregateMaximumBitRateUplink_t& ref_uEaggregateMaximumBitRateUplink() {return uEaggregateMaximumBitRateUplink;}
34261 uEaggregateMaximumBitRateUplink_t const& ref_uEaggregateMaximumBitRateUplink() const {return uEaggregateMaximumBitRateUplink;}
34262 struct iE_Extensions_t : ProtocolExtensionContainer<UEAggregate_MaximumBitrate_ExtIEs>
34264 static constexpr const char* name() {return "iE_Extensions_t";}
34265 using parent_t = ProtocolExtensionContainer<UEAggregate_MaximumBitrate_ExtIEs>;
34266 static constexpr bool optional = true;
34269 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
34270 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
34271 template<typename V> void decode(V& v)
34273 v(uEaggregateMaximumBitRateDownlink);
34274 v(uEaggregateMaximumBitRateUplink);
34278 template<typename V> void encode(V& v) const
34280 v(uEaggregateMaximumBitRateDownlink);
34281 v(uEaggregateMaximumBitRateUplink);
34287 uEaggregateMaximumBitRateDownlink.clear();
34288 uEaggregateMaximumBitRateUplink.clear();
34289 iE_Extensions.clear();
34293 uEaggregateMaximumBitRateDownlink_t uEaggregateMaximumBitRateDownlink;
34294 uEaggregateMaximumBitRateUplink_t uEaggregateMaximumBitRateUplink;
34295 iE_Extensions_t iE_Extensions;
34299 UENRMeasurement-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
34304 struct UENRMeasurement_ExtIEs
34306 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
34308 size_t get_index() const {return type;}
34309 bool is_unknown() const { return type == 1; }
34310 void clear() {type = 0;}
34311 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
34312 template<typename V> bool decode(V& v)
34315 if(!v(ref_nested())) return false;
34316 { type = 1; return true;}
34320 template<typename V> bool encode(V& v) const
34322 return v(ref_nested());
34326 template<typename V> bool decode(size_t index, V& v)
34331 case 1: type = 1; return v(ref_nested());
34332 ref_nested().clear();
34337 template<typename V> bool encode(size_t index, V& v) const
34339 if(index != type) {return false;} return v(ref_nested());
34346 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
34348 size_t get_index() const {return type;}
34349 bool is_unknown() const { return type == 1; }
34350 void clear() {type = 0;}
34351 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
34352 template<typename V> bool decode(V& v)
34355 if(!v(ref_nested())) return false;
34356 { type = 1; return true;}
34360 template<typename V> bool encode(V& v) const
34362 return v(ref_nested());
34366 template<typename V> bool decode(size_t index, V& v)
34371 case 1: type = 1; return v(ref_nested());
34372 ref_nested().clear();
34377 template<typename V> bool encode(size_t index, V& v) const
34379 if(index != type) {return false;} return v(ref_nested());
34386 struct Extension_t : asn::typefield<true>
34388 ~Extension_t() {clear();}
34389 size_t get_index() const {return type;}
34390 bool is_unknown() const { return type == 1; }
34393 type = 0; ref_nested().clear();
34395 template<typename V> static inline void enumerate(V& v)
34400 template<typename V> bool decode(size_t index, V& v)
34405 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
34410 template<typename V> bool encode(size_t index, V& v) const
34412 if(index != type) return false;
34420 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
34422 size_t get_index() const {return type;}
34423 bool is_unknown() const { return type == 1; }
34424 void clear() {type = 0;}
34425 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
34426 template<typename V> bool decode(V& v)
34429 if(!v(ref_nested())) return false;
34430 { type = 1; return true;}
34434 template<typename V> bool encode(V& v) const
34436 return v(ref_nested());
34440 template<typename V> bool decode(size_t index, V& v)
34445 case 1: type = 1; return v(ref_nested());
34446 ref_nested().clear();
34451 template<typename V> bool encode(size_t index, V& v) const
34453 if(index != type) {return false;} return v(ref_nested());
34463 UENRMeasurement ::= SEQUENCE {
34464 uENRMeasurements RRCContainer,
34465 iE-Extensions ProtocolExtensionContainer { {UENRMeasurement-ExtIEs} } OPTIONAL,
34470 struct UENRMeasurement : asn::sequence<2, 0, true, 1>
34472 static constexpr const char* name() {return "UENRMeasurement";}
34473 using parent_t = asn::sequence<2, 0, true, 1>;
34474 struct uENRMeasurements_t : RRCContainer
34476 static constexpr const char* name() {return "uENRMeasurements_t";}
34477 using parent_t = RRCContainer;
34480 uENRMeasurements_t& ref_uENRMeasurements() {return uENRMeasurements;}
34481 uENRMeasurements_t const& ref_uENRMeasurements() const {return uENRMeasurements;}
34482 struct iE_Extensions_t : ProtocolExtensionContainer<UENRMeasurement_ExtIEs>
34484 static constexpr const char* name() {return "iE_Extensions_t";}
34485 using parent_t = ProtocolExtensionContainer<UENRMeasurement_ExtIEs>;
34486 static constexpr bool optional = true;
34489 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
34490 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
34491 template<typename V> void decode(V& v)
34493 v(uENRMeasurements);
34497 template<typename V> void encode(V& v) const
34499 v(uENRMeasurements);
34505 uENRMeasurements.clear();
34506 iE_Extensions.clear();
34510 uENRMeasurements_t uENRMeasurements;
34511 iE_Extensions_t iE_Extensions;
34515 UESecurityCapabilities-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
34520 struct UESecurityCapabilities_ExtIEs
34522 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
34524 size_t get_index() const {return type;}
34525 bool is_unknown() const { return type == 1; }
34526 void clear() {type = 0;}
34527 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
34528 template<typename V> bool decode(V& v)
34531 if(!v(ref_nested())) return false;
34532 { type = 1; return true;}
34536 template<typename V> bool encode(V& v) const
34538 return v(ref_nested());
34542 template<typename V> bool decode(size_t index, V& v)
34547 case 1: type = 1; return v(ref_nested());
34548 ref_nested().clear();
34553 template<typename V> bool encode(size_t index, V& v) const
34555 if(index != type) {return false;} return v(ref_nested());
34562 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
34564 size_t get_index() const {return type;}
34565 bool is_unknown() const { return type == 1; }
34566 void clear() {type = 0;}
34567 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
34568 template<typename V> bool decode(V& v)
34571 if(!v(ref_nested())) return false;
34572 { type = 1; return true;}
34576 template<typename V> bool encode(V& v) const
34578 return v(ref_nested());
34582 template<typename V> bool decode(size_t index, V& v)
34587 case 1: type = 1; return v(ref_nested());
34588 ref_nested().clear();
34593 template<typename V> bool encode(size_t index, V& v) const
34595 if(index != type) {return false;} return v(ref_nested());
34602 struct Extension_t : asn::typefield<true>
34604 ~Extension_t() {clear();}
34605 size_t get_index() const {return type;}
34606 bool is_unknown() const { return type == 1; }
34609 type = 0; ref_nested().clear();
34611 template<typename V> static inline void enumerate(V& v)
34616 template<typename V> bool decode(size_t index, V& v)
34621 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
34626 template<typename V> bool encode(size_t index, V& v) const
34628 if(index != type) return false;
34636 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
34638 size_t get_index() const {return type;}
34639 bool is_unknown() const { return type == 1; }
34640 void clear() {type = 0;}
34641 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
34642 template<typename V> bool decode(V& v)
34645 if(!v(ref_nested())) return false;
34646 { type = 1; return true;}
34650 template<typename V> bool encode(V& v) const
34652 return v(ref_nested());
34656 template<typename V> bool decode(size_t index, V& v)
34661 case 1: type = 1; return v(ref_nested());
34662 ref_nested().clear();
34667 template<typename V> bool encode(size_t index, V& v) const
34669 if(index != type) {return false;} return v(ref_nested());
34679 UESecurityCapabilities ::= SEQUENCE {
34680 encryptionAlgorithms EncryptionAlgorithms,
34681 integrityProtectionAlgorithms IntegrityProtectionAlgorithms,
34682 iE-Extensions ProtocolExtensionContainer { {UESecurityCapabilities-ExtIEs} } OPTIONAL,
34687 struct UESecurityCapabilities : asn::sequence<3, 0, true, 1>
34689 static constexpr const char* name() {return "UESecurityCapabilities";}
34690 using parent_t = asn::sequence<3, 0, true, 1>;
34691 struct encryptionAlgorithms_t : EncryptionAlgorithms
34693 static constexpr const char* name() {return "encryptionAlgorithms_t";}
34694 using parent_t = EncryptionAlgorithms;
34697 encryptionAlgorithms_t& ref_encryptionAlgorithms() {return encryptionAlgorithms;}
34698 encryptionAlgorithms_t const& ref_encryptionAlgorithms() const {return encryptionAlgorithms;}
34699 struct integrityProtectionAlgorithms_t : IntegrityProtectionAlgorithms
34701 static constexpr const char* name() {return "integrityProtectionAlgorithms_t";}
34702 using parent_t = IntegrityProtectionAlgorithms;
34705 integrityProtectionAlgorithms_t& ref_integrityProtectionAlgorithms() {return integrityProtectionAlgorithms;}
34706 integrityProtectionAlgorithms_t const& ref_integrityProtectionAlgorithms() const {return integrityProtectionAlgorithms;}
34707 struct iE_Extensions_t : ProtocolExtensionContainer<UESecurityCapabilities_ExtIEs>
34709 static constexpr const char* name() {return "iE_Extensions_t";}
34710 using parent_t = ProtocolExtensionContainer<UESecurityCapabilities_ExtIEs>;
34711 static constexpr bool optional = true;
34714 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
34715 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
34716 template<typename V> void decode(V& v)
34718 v(encryptionAlgorithms);
34719 v(integrityProtectionAlgorithms);
34723 template<typename V> void encode(V& v) const
34725 v(encryptionAlgorithms);
34726 v(integrityProtectionAlgorithms);
34732 encryptionAlgorithms.clear();
34733 integrityProtectionAlgorithms.clear();
34734 iE_Extensions.clear();
34738 encryptionAlgorithms_t encryptionAlgorithms;
34739 integrityProtectionAlgorithms_t integrityProtectionAlgorithms;
34740 iE_Extensions_t iE_Extensions;
34744 UESidelinkAggregateMaximumBitRate ::= SEQUENCE {
34745 uESidelinkAggregateMaximumBitRate BitRate,
34746 iE-Extensions ProtocolExtensionContainer { {UE-Sidelink-Aggregate-MaximumBitRate-ExtIEs} } OPTIONAL,
34751 struct UESidelinkAggregateMaximumBitRate : asn::sequence<2, 0, true, 1>
34753 static constexpr const char* name() {return "UESidelinkAggregateMaximumBitRate";}
34754 using parent_t = asn::sequence<2, 0, true, 1>;
34755 struct uESidelinkAggregateMaximumBitRate_t : BitRate
34757 static constexpr const char* name() {return "uESidelinkAggregateMaximumBitRate_t";}
34758 using parent_t = BitRate;
34761 uESidelinkAggregateMaximumBitRate_t& ref_uESidelinkAggregateMaximumBitRate() {return uESidelinkAggregateMaximumBitRate;}
34762 uESidelinkAggregateMaximumBitRate_t const& ref_uESidelinkAggregateMaximumBitRate() const {return uESidelinkAggregateMaximumBitRate;}
34763 struct iE_Extensions_t : ProtocolExtensionContainer<UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs>
34765 static constexpr const char* name() {return "iE_Extensions_t";}
34766 using parent_t = ProtocolExtensionContainer<UE_Sidelink_Aggregate_MaximumBitRate_ExtIEs>;
34767 static constexpr bool optional = true;
34770 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
34771 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
34772 template<typename V> void decode(V& v)
34774 v(uESidelinkAggregateMaximumBitRate);
34778 template<typename V> void encode(V& v) const
34780 v(uESidelinkAggregateMaximumBitRate);
34786 uESidelinkAggregateMaximumBitRate.clear();
34787 iE_Extensions.clear();
34791 uESidelinkAggregateMaximumBitRate_t uESidelinkAggregateMaximumBitRate;
34792 iE_Extensions_t iE_Extensions;
34796 UEsToBeResetList-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
34801 struct UEsToBeResetList_Item_ExtIEs
34803 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
34805 size_t get_index() const {return type;}
34806 bool is_unknown() const { return type == 1; }
34807 void clear() {type = 0;}
34808 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
34809 template<typename V> bool decode(V& v)
34812 if(!v(ref_nested())) return false;
34813 { type = 1; return true;}
34817 template<typename V> bool encode(V& v) const
34819 return v(ref_nested());
34823 template<typename V> bool decode(size_t index, V& v)
34828 case 1: type = 1; return v(ref_nested());
34829 ref_nested().clear();
34834 template<typename V> bool encode(size_t index, V& v) const
34836 if(index != type) {return false;} return v(ref_nested());
34843 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
34845 size_t get_index() const {return type;}
34846 bool is_unknown() const { return type == 1; }
34847 void clear() {type = 0;}
34848 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
34849 template<typename V> bool decode(V& v)
34852 if(!v(ref_nested())) return false;
34853 { type = 1; return true;}
34857 template<typename V> bool encode(V& v) const
34859 return v(ref_nested());
34863 template<typename V> bool decode(size_t index, V& v)
34868 case 1: type = 1; return v(ref_nested());
34869 ref_nested().clear();
34874 template<typename V> bool encode(size_t index, V& v) const
34876 if(index != type) {return false;} return v(ref_nested());
34883 struct Extension_t : asn::typefield<true>
34885 ~Extension_t() {clear();}
34886 size_t get_index() const {return type;}
34887 bool is_unknown() const { return type == 1; }
34890 type = 0; ref_nested().clear();
34892 template<typename V> static inline void enumerate(V& v)
34897 template<typename V> bool decode(size_t index, V& v)
34902 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
34907 template<typename V> bool encode(size_t index, V& v) const
34909 if(index != type) return false;
34917 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
34919 size_t get_index() const {return type;}
34920 bool is_unknown() const { return type == 1; }
34921 void clear() {type = 0;}
34922 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
34923 template<typename V> bool decode(V& v)
34926 if(!v(ref_nested())) return false;
34927 { type = 1; return true;}
34931 template<typename V> bool encode(V& v) const
34933 return v(ref_nested());
34937 template<typename V> bool decode(size_t index, V& v)
34942 case 1: type = 1; return v(ref_nested());
34943 ref_nested().clear();
34948 template<typename V> bool encode(size_t index, V& v) const
34950 if(index != type) {return false;} return v(ref_nested());
34960 UEsToBeResetList-Item::= SEQUENCE {
34961 meNB-ID UE-X2AP-ID,
34962 meNB-ID-ext UE-X2AP-ID-Extension OPTIONAL,
34963 sgNB-ID SgNB-UE-X2AP-ID OPTIONAL,
34964 iE-Extensions ProtocolExtensionContainer { {UEsToBeResetList-Item-ExtIEs} } OPTIONAL,
34969 struct UEsToBeResetList_Item : asn::sequence<4, 0, true, 3>
34971 static constexpr const char* name() {return "UEsToBeResetList-Item";}
34972 using parent_t = asn::sequence<4, 0, true, 3>;
34973 struct meNB_ID_t : UE_X2AP_ID
34975 static constexpr const char* name() {return "meNB_ID_t";}
34976 using parent_t = UE_X2AP_ID;
34979 meNB_ID_t& ref_meNB_ID() {return meNB_ID;}
34980 meNB_ID_t const& ref_meNB_ID() const {return meNB_ID;}
34981 struct meNB_ID_ext_t : UE_X2AP_ID_Extension
34983 static constexpr const char* name() {return "meNB_ID_ext_t";}
34984 using parent_t = UE_X2AP_ID_Extension;
34985 static constexpr bool optional = true;
34988 meNB_ID_ext_t& set_meNB_ID_ext() { meNB_ID_ext.setpresent(true); return meNB_ID_ext;}
34989 meNB_ID_ext_t const* get_meNB_ID_ext() const {return meNB_ID_ext.is_valid() ? &meNB_ID_ext : nullptr;}
34990 struct sgNB_ID_t : SgNB_UE_X2AP_ID
34992 static constexpr const char* name() {return "sgNB_ID_t";}
34993 using parent_t = SgNB_UE_X2AP_ID;
34994 static constexpr bool optional = true;
34997 sgNB_ID_t& set_sgNB_ID() { sgNB_ID.setpresent(true); return sgNB_ID;}
34998 sgNB_ID_t const* get_sgNB_ID() const {return sgNB_ID.is_valid() ? &sgNB_ID : nullptr;}
34999 struct iE_Extensions_t : ProtocolExtensionContainer<UEsToBeResetList_Item_ExtIEs>
35001 static constexpr const char* name() {return "iE_Extensions_t";}
35002 using parent_t = ProtocolExtensionContainer<UEsToBeResetList_Item_ExtIEs>;
35003 static constexpr bool optional = true;
35006 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
35007 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
35008 template<typename V> void decode(V& v)
35016 template<typename V> void encode(V& v) const
35027 meNB_ID_ext.clear();
35029 iE_Extensions.clear();
35034 meNB_ID_ext_t meNB_ID_ext;
35036 iE_Extensions_t iE_Extensions;
35040 UEsToBeResetList ::= SEQUENCE (SIZE (1.. maxUEsinengNBDU)) OF UEsToBeResetList-Item
35043 struct UEsToBeResetList_elm : UEsToBeResetList_Item
35045 static constexpr const char* name() {return "UEsToBeResetList_elm";}
35046 using parent_t = UEsToBeResetList_Item;
35049 struct UEsToBeResetList : asn::sequenceof<UEsToBeResetList_elm>
35051 static constexpr const char* name() {return "UEsToBeResetList";}
35052 using parent_t = asn::sequenceof<UEsToBeResetList_elm>;
35053 using constraint_t = asn::constraints<false,asn::span<1, maxUEsinengNBDU >>;
35057 UL-HighInterferenceIndication ::= BIT STRING (SIZE(1..110, ...))
35060 struct UL_HighInterferenceIndication : asn::bstring<>
35062 using constraint_t = asn::constraints<true,asn::span<1, 110>>;
35063 static constexpr const char* name() {return "UL-HighInterferenceIndication";}
35064 using parent_t = asn::bstring<>;
35069 UL-HighInterferenceIndicationInfo-Item-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
35074 struct UL_HighInterferenceIndicationInfo_Item_ExtIEs
35076 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
35078 size_t get_index() const {return type;}
35079 bool is_unknown() const { return type == 1; }
35080 void clear() {type = 0;}
35081 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
35082 template<typename V> bool decode(V& v)
35085 if(!v(ref_nested())) return false;
35086 { type = 1; return true;}
35090 template<typename V> bool encode(V& v) const
35092 return v(ref_nested());
35096 template<typename V> bool decode(size_t index, V& v)
35101 case 1: type = 1; return v(ref_nested());
35102 ref_nested().clear();
35107 template<typename V> bool encode(size_t index, V& v) const
35109 if(index != type) {return false;} return v(ref_nested());
35116 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
35118 size_t get_index() const {return type;}
35119 bool is_unknown() const { return type == 1; }
35120 void clear() {type = 0;}
35121 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
35122 template<typename V> bool decode(V& v)
35125 if(!v(ref_nested())) return false;
35126 { type = 1; return true;}
35130 template<typename V> bool encode(V& v) const
35132 return v(ref_nested());
35136 template<typename V> bool decode(size_t index, V& v)
35141 case 1: type = 1; return v(ref_nested());
35142 ref_nested().clear();
35147 template<typename V> bool encode(size_t index, V& v) const
35149 if(index != type) {return false;} return v(ref_nested());
35156 struct Extension_t : asn::typefield<true>
35158 ~Extension_t() {clear();}
35159 size_t get_index() const {return type;}
35160 bool is_unknown() const { return type == 1; }
35163 type = 0; ref_nested().clear();
35165 template<typename V> static inline void enumerate(V& v)
35170 template<typename V> bool decode(size_t index, V& v)
35175 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
35180 template<typename V> bool encode(size_t index, V& v) const
35182 if(index != type) return false;
35190 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
35192 size_t get_index() const {return type;}
35193 bool is_unknown() const { return type == 1; }
35194 void clear() {type = 0;}
35195 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
35196 template<typename V> bool decode(V& v)
35199 if(!v(ref_nested())) return false;
35200 { type = 1; return true;}
35204 template<typename V> bool encode(V& v) const
35206 return v(ref_nested());
35210 template<typename V> bool decode(size_t index, V& v)
35215 case 1: type = 1; return v(ref_nested());
35216 ref_nested().clear();
35221 template<typename V> bool encode(size_t index, V& v) const
35223 if(index != type) {return false;} return v(ref_nested());
35233 UL-HighInterferenceIndicationInfo-Item ::= SEQUENCE {
35234 target-Cell-ID ECGI,
35235 ul-interferenceindication UL-HighInterferenceIndication,
35236 iE-Extensions ProtocolExtensionContainer { {UL-HighInterferenceIndicationInfo-Item-ExtIEs} } OPTIONAL,
35241 struct UL_HighInterferenceIndicationInfo_Item : asn::sequence<3, 0, true, 1>
35243 static constexpr const char* name() {return "UL-HighInterferenceIndicationInfo-Item";}
35244 using parent_t = asn::sequence<3, 0, true, 1>;
35245 struct target_Cell_ID_t : ECGI
35247 static constexpr const char* name() {return "target_Cell_ID_t";}
35248 using parent_t = ECGI;
35251 target_Cell_ID_t& ref_target_Cell_ID() {return target_Cell_ID;}
35252 target_Cell_ID_t const& ref_target_Cell_ID() const {return target_Cell_ID;}
35253 struct ul_interferenceindication_t : UL_HighInterferenceIndication
35255 static constexpr const char* name() {return "ul_interferenceindication_t";}
35256 using parent_t = UL_HighInterferenceIndication;
35259 ul_interferenceindication_t& ref_ul_interferenceindication() {return ul_interferenceindication;}
35260 ul_interferenceindication_t const& ref_ul_interferenceindication() const {return ul_interferenceindication;}
35261 struct iE_Extensions_t : ProtocolExtensionContainer<UL_HighInterferenceIndicationInfo_Item_ExtIEs>
35263 static constexpr const char* name() {return "iE_Extensions_t";}
35264 using parent_t = ProtocolExtensionContainer<UL_HighInterferenceIndicationInfo_Item_ExtIEs>;
35265 static constexpr bool optional = true;
35268 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
35269 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
35270 template<typename V> void decode(V& v)
35273 v(ul_interferenceindication);
35277 template<typename V> void encode(V& v) const
35280 v(ul_interferenceindication);
35286 target_Cell_ID.clear();
35287 ul_interferenceindication.clear();
35288 iE_Extensions.clear();
35292 target_Cell_ID_t target_Cell_ID;
35293 ul_interferenceindication_t ul_interferenceindication;
35294 iE_Extensions_t iE_Extensions;
35298 UL-HighInterferenceIndicationInfo ::= SEQUENCE (SIZE(1..maxCellineNB)) OF UL-HighInterferenceIndicationInfo-Item
35301 struct UL_HighInterferenceIndicationInfo_elm : UL_HighInterferenceIndicationInfo_Item
35303 static constexpr const char* name() {return "UL_HighInterferenceIndicationInfo_elm";}
35304 using parent_t = UL_HighInterferenceIndicationInfo_Item;
35307 struct UL_HighInterferenceIndicationInfo : asn::sequenceof<UL_HighInterferenceIndicationInfo_elm>
35309 static constexpr const char* name() {return "UL-HighInterferenceIndicationInfo";}
35310 using parent_t = asn::sequenceof<UL_HighInterferenceIndicationInfo_elm>;
35311 using constraint_t = asn::constraints<false,asn::span<1, maxCellineNB >>;
35315 UL-UE-Configuration::= ENUMERATED { no-data, shared, only, ... }
35318 struct UL_UE_Configuration : asn::enumerated<3, 0, true>
35320 static constexpr const char* name() {return "UL-UE-Configuration";}
35321 using parent_t = asn::enumerated<3, 0, true>;
35331 ULConfiguration-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
35336 struct ULConfiguration_ExtIEs
35338 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
35340 size_t get_index() const {return type;}
35341 bool is_unknown() const { return type == 1; }
35342 void clear() {type = 0;}
35343 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
35344 template<typename V> bool decode(V& v)
35347 if(!v(ref_nested())) return false;
35348 { type = 1; return true;}
35352 template<typename V> bool encode(V& v) const
35354 return v(ref_nested());
35358 template<typename V> bool decode(size_t index, V& v)
35363 case 1: type = 1; return v(ref_nested());
35364 ref_nested().clear();
35369 template<typename V> bool encode(size_t index, V& v) const
35371 if(index != type) {return false;} return v(ref_nested());
35378 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
35380 size_t get_index() const {return type;}
35381 bool is_unknown() const { return type == 1; }
35382 void clear() {type = 0;}
35383 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
35384 template<typename V> bool decode(V& v)
35387 if(!v(ref_nested())) return false;
35388 { type = 1; return true;}
35392 template<typename V> bool encode(V& v) const
35394 return v(ref_nested());
35398 template<typename V> bool decode(size_t index, V& v)
35403 case 1: type = 1; return v(ref_nested());
35404 ref_nested().clear();
35409 template<typename V> bool encode(size_t index, V& v) const
35411 if(index != type) {return false;} return v(ref_nested());
35418 struct Extension_t : asn::typefield<true>
35420 ~Extension_t() {clear();}
35421 size_t get_index() const {return type;}
35422 bool is_unknown() const { return type == 1; }
35425 type = 0; ref_nested().clear();
35427 template<typename V> static inline void enumerate(V& v)
35432 template<typename V> bool decode(size_t index, V& v)
35437 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
35442 template<typename V> bool encode(size_t index, V& v) const
35444 if(index != type) return false;
35452 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
35454 size_t get_index() const {return type;}
35455 bool is_unknown() const { return type == 1; }
35456 void clear() {type = 0;}
35457 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
35458 template<typename V> bool decode(V& v)
35461 if(!v(ref_nested())) return false;
35462 { type = 1; return true;}
35466 template<typename V> bool encode(V& v) const
35468 return v(ref_nested());
35472 template<typename V> bool decode(size_t index, V& v)
35477 case 1: type = 1; return v(ref_nested());
35478 ref_nested().clear();
35483 template<typename V> bool encode(size_t index, V& v) const
35485 if(index != type) {return false;} return v(ref_nested());
35495 ULConfiguration::= SEQUENCE {
35496 uL-PDCP UL-UE-Configuration,
35497 iE-Extensions ProtocolExtensionContainer { {ULConfiguration-ExtIEs} } OPTIONAL,
35502 struct ULConfiguration : asn::sequence<2, 0, true, 1>
35504 static constexpr const char* name() {return "ULConfiguration";}
35505 using parent_t = asn::sequence<2, 0, true, 1>;
35506 struct uL_PDCP_t : UL_UE_Configuration
35508 static constexpr const char* name() {return "uL_PDCP_t";}
35509 using parent_t = UL_UE_Configuration;
35512 uL_PDCP_t& ref_uL_PDCP() {return uL_PDCP;}
35513 uL_PDCP_t const& ref_uL_PDCP() const {return uL_PDCP;}
35514 struct iE_Extensions_t : ProtocolExtensionContainer<ULConfiguration_ExtIEs>
35516 static constexpr const char* name() {return "iE_Extensions_t";}
35517 using parent_t = ProtocolExtensionContainer<ULConfiguration_ExtIEs>;
35518 static constexpr bool optional = true;
35521 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
35522 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
35523 template<typename V> void decode(V& v)
35529 template<typename V> void encode(V& v) const
35538 iE_Extensions.clear();
35543 iE_Extensions_t iE_Extensions;
35547 VehicleUE ::= ENUMERATED {
35554 struct VehicleUE : asn::enumerated<2, 0, true>
35556 static constexpr const char* name() {return "VehicleUE";}
35557 using parent_t = asn::enumerated<2, 0, true>;
35566 V2XServicesAuthorized-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
35571 struct V2XServicesAuthorized_ExtIEs
35573 struct id_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::id_t, true>
35575 size_t get_index() const {return type;}
35576 bool is_unknown() const { return type == 1; }
35577 void clear() {type = 0;}
35578 X2AP_PROTOCOL_EXTENSION::id_t const& ref_value() const {return ref_nested();}
35579 template<typename V> bool decode(V& v)
35582 if(!v(ref_nested())) return false;
35583 { type = 1; return true;}
35587 template<typename V> bool encode(V& v) const
35589 return v(ref_nested());
35593 template<typename V> bool decode(size_t index, V& v)
35598 case 1: type = 1; return v(ref_nested());
35599 ref_nested().clear();
35604 template<typename V> bool encode(size_t index, V& v) const
35606 if(index != type) {return false;} return v(ref_nested());
35613 struct criticality_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::criticality_t, true>
35615 size_t get_index() const {return type;}
35616 bool is_unknown() const { return type == 1; }
35617 void clear() {type = 0;}
35618 X2AP_PROTOCOL_EXTENSION::criticality_t const& ref_value() const {return ref_nested();}
35619 template<typename V> bool decode(V& v)
35622 if(!v(ref_nested())) return false;
35623 { type = 1; return true;}
35627 template<typename V> bool encode(V& v) const
35629 return v(ref_nested());
35633 template<typename V> bool decode(size_t index, V& v)
35638 case 1: type = 1; return v(ref_nested());
35639 ref_nested().clear();
35644 template<typename V> bool encode(size_t index, V& v) const
35646 if(index != type) {return false;} return v(ref_nested());
35653 struct Extension_t : asn::typefield<true>
35655 ~Extension_t() {clear();}
35656 size_t get_index() const {return type;}
35657 bool is_unknown() const { return type == 1; }
35660 type = 0; ref_nested().clear();
35662 template<typename V> static inline void enumerate(V& v)
35667 template<typename V> bool decode(size_t index, V& v)
35672 case 1: if(type != 1) {clear(); asn::base::set();} type = 1; return true;
35677 template<typename V> bool encode(size_t index, V& v) const
35679 if(index != type) return false;
35687 struct presence_t : asn::fixedtypefield<X2AP_PROTOCOL_EXTENSION::presence_t, true>
35689 size_t get_index() const {return type;}
35690 bool is_unknown() const { return type == 1; }
35691 void clear() {type = 0;}
35692 X2AP_PROTOCOL_EXTENSION::presence_t const& ref_value() const {return ref_nested();}
35693 template<typename V> bool decode(V& v)
35696 if(!v(ref_nested())) return false;
35697 { type = 1; return true;}
35701 template<typename V> bool encode(V& v) const
35703 return v(ref_nested());
35707 template<typename V> bool decode(size_t index, V& v)
35712 case 1: type = 1; return v(ref_nested());
35713 ref_nested().clear();
35718 template<typename V> bool encode(size_t index, V& v) const
35720 if(index != type) {return false;} return v(ref_nested());
35730 V2XServicesAuthorized ::= SEQUENCE {
35731 vehicleUE VehicleUE OPTIONAL,
35732 pedestrianUE PedestrianUE OPTIONAL,
35733 iE-Extensions ProtocolExtensionContainer { {V2XServicesAuthorized-ExtIEs} } OPTIONAL,
35738 struct V2XServicesAuthorized : asn::sequence<3, 0, true, 3>
35740 static constexpr const char* name() {return "V2XServicesAuthorized";}
35741 using parent_t = asn::sequence<3, 0, true, 3>;
35742 struct vehicleUE_t : VehicleUE
35744 static constexpr const char* name() {return "vehicleUE_t";}
35745 using parent_t = VehicleUE;
35746 static constexpr bool optional = true;
35749 vehicleUE_t& set_vehicleUE() { vehicleUE.setpresent(true); return vehicleUE;}
35750 vehicleUE_t const* get_vehicleUE() const {return vehicleUE.is_valid() ? &vehicleUE : nullptr;}
35751 struct pedestrianUE_t : PedestrianUE
35753 static constexpr const char* name() {return "pedestrianUE_t";}
35754 using parent_t = PedestrianUE;
35755 static constexpr bool optional = true;
35758 pedestrianUE_t& set_pedestrianUE() { pedestrianUE.setpresent(true); return pedestrianUE;}
35759 pedestrianUE_t const* get_pedestrianUE() const {return pedestrianUE.is_valid() ? &pedestrianUE : nullptr;}
35760 struct iE_Extensions_t : ProtocolExtensionContainer<V2XServicesAuthorized_ExtIEs>
35762 static constexpr const char* name() {return "iE_Extensions_t";}
35763 using parent_t = ProtocolExtensionContainer<V2XServicesAuthorized_ExtIEs>;
35764 static constexpr bool optional = true;
35767 iE_Extensions_t& set_iE_Extensions() { iE_Extensions.setpresent(true); return iE_Extensions;}
35768 iE_Extensions_t const* get_iE_Extensions() const {return iE_Extensions.is_valid() ? &iE_Extensions : nullptr;}
35769 template<typename V> void decode(V& v)
35776 template<typename V> void encode(V& v) const
35786 pedestrianUE.clear();
35787 iE_Extensions.clear();
35791 vehicleUE_t vehicleUE;
35792 pedestrianUE_t pedestrianUE;
35793 iE_Extensions_t iE_Extensions;
35797 WT-UE-XwAP-ID ::= OCTET STRING (SIZE (3))
35800 struct WT_UE_XwAP_ID : asn::ostring<>
35802 using constraint_t = asn::constraints<false,asn::one<3>>;
35803 static constexpr const char* name() {return "WT-UE-XwAP-ID";}
35804 using parent_t = asn::ostring<>;
35809 WTID-Type1 ::= SEQUENCE {
35810 pLMN-Identity PLMN-Identity,
35811 shortWTID BIT STRING (SIZE(24)),
35816 struct WTID_Type1 : asn::sequence<2, 0, true, 0>
35818 static constexpr const char* name() {return "WTID-Type1";}
35819 using parent_t = asn::sequence<2, 0, true, 0>;
35820 struct pLMN_Identity_t : PLMN_Identity
35822 static constexpr const char* name() {return "pLMN_Identity_t";}
35823 using parent_t = PLMN_Identity;
35826 pLMN_Identity_t& ref_pLMN_Identity() {return pLMN_Identity;}
35827 pLMN_Identity_t const& ref_pLMN_Identity() const {return pLMN_Identity;}
35828 struct shortWTID_t : asn::bstring<>
35830 using constraint_t = asn::constraints<false,asn::one<24>>;
35831 static constexpr const char* name() {return "shortWTID_t";}
35832 using parent_t = asn::bstring<>;
35836 shortWTID_t& ref_shortWTID() {return shortWTID;}
35837 shortWTID_t const& ref_shortWTID() const {return shortWTID;}
35838 template<typename V> void decode(V& v)
35844 template<typename V> void encode(V& v) const
35852 pLMN_Identity.clear();
35857 pLMN_Identity_t pLMN_Identity;
35858 shortWTID_t shortWTID;
35862 WTID-Long-Type2 ::= BIT STRING (SIZE(48))
35865 struct WTID_Long_Type2 : asn::bstring<>
35867 using constraint_t = asn::constraints<false,asn::one<48>>;
35868 static constexpr const char* name() {return "WTID-Long-Type2";}
35869 using parent_t = asn::bstring<>;
35875 wTID-Type1 WTID-Type1,
35876 wTID-Type2 WTID-Long-Type2,
35881 struct WTID : asn::choice<2, 0, true>
35883 static constexpr const char* name() {return "WTID";}
35884 using parent_t = asn::choice<2, 0, true>;
35885 index_type get_index() const {return index;}
35886 bool is_unknown() const {return index == 3;}
35887 void set_unknown() { set_index(3); }
35889 struct wTID_Type1_t : WTID_Type1
35891 static constexpr const char* name() {return "wTID_Type1_t";}
35892 using parent_t = WTID_Type1;
35895 struct wTID_Type2_t : WTID_Long_Type2
35897 static constexpr const char* name() {return "wTID_Type2_t";}
35898 using parent_t = WTID_Long_Type2;
35903 switch(get_index())
35905 case 1: var.destroy<wTID_Type1_t>(); break;
35906 case 2: var.destroy<wTID_Type2_t>(); break;
35911 template<typename V> bool decode(size_t idx, V& v)
35916 case 1: set_index(1); return v(var.build<wTID_Type1_t>());
35917 case 2: set_index(2); return v(var.build<wTID_Type2_t>());
35922 template<typename V> bool encode(V& v) const
35924 switch(get_index())
35926 case 1: return v(var.as<wTID_Type1_t>());
35927 case 2: return v(var.as<wTID_Type2_t>());
35931 template<typename V> static inline void enumerate(V& v)
35933 v.template operator()<wTID_Type1_t>(1);
35934 v.template operator()<wTID_Type2_t>(2);
35937 wTID_Type1_t& select_wTID_Type1() { if(get_index() != 1) { clear(); set_index(1); return var.build<wTID_Type1_t>();} return var.as<wTID_Type1_t>();}
35938 wTID_Type1_t const* get_wTID_Type1() const { if(get_index() == 1) { return &var.as<wTID_Type1_t>();} return nullptr; }
35939 wTID_Type2_t& select_wTID_Type2() { if(get_index() != 2) { clear(); set_index(2); return var.build<wTID_Type2_t>();} return var.as<wTID_Type2_t>();}
35940 wTID_Type2_t const* get_wTID_Type2() const { if(get_index() == 2) { return &var.as<wTID_Type2_t>();} return nullptr; }
35942 void set_index(index_type i) {index = i; base::set();}
35945 char dummy1[sizeof(wTID_Type1_t)];
35946 char dummy2[sizeof(wTID_Type2_t)];
35949 asn::variant<sizeof(union_type)> var;
35950 index_type index {0};
35953 X2BenefitValue ::= INTEGER (1..8, ...)
35956 struct X2BenefitValue : asn::integer<>
35958 using constraint_t = asn::constraints<true,asn::span<1, 8>>;
35959 static constexpr const char* name() {return "X2BenefitValue";}
35960 using parent_t = asn::integer<>;